public function testDefaultSearchField()
{
$currentDefaultSearchField = Lucene\Lucene::getDefaultSearchField();
$this->assertEquals($currentDefaultSearchField, null);
Lucene\Lucene::setDefaultSearchField('anotherField');
$this->assertEquals(Lucene\Lucene::getDefaultSearchField(), 'anotherField');
Lucene\Lucene::setDefaultSearchField($currentDefaultSearchField);
}
public function testDefaultSearchField()
{
$index = Lucene\Lucene::open(__DIR__ . '/_index23Sample/_files');
$storedDefaultSearchField = Lucene\Lucene::getDefaultSearchField();
Lucene\Lucene::setDefaultSearchField('path');
$hits = $index->find('contributing');
$this->assertEquals(count($hits), 5);
$expectedResultset = array(array(8, 0.847922, 'IndexSource/contributing.html'), array(0, 0.678337, 'IndexSource/contributing.documentation.html'), array(1, 0.678337, 'IndexSource/contributing.wishlist.html'), array(2, 0.678337, 'IndexSource/contributing.patches.html'), array(7, 0.678337, 'IndexSource/contributing.bugs.html'));
foreach ($hits as $resId => $hit) {
$this->assertEquals($hit->id, $expectedResultset[$resId][0]);
$this->assertTrue(abs($hit->score - $expectedResultset[$resId][1]) < 1.0E-6);
$this->assertEquals($hit->path, $expectedResultset[$resId][2]);
}
Lucene\Lucene::setDefaultSearchField($storedDefaultSearchField);
}
public function DefaultSearchField()
{
return Lucene::getDefaultSearchField();
}
/**
* Object constructor
*/
public function __construct($text, $field = null)
{
$this->field = $field === null ? Lucene\Lucene::getDefaultSearchField() : $field;
$this->text = $text;
}
/**
* Re-write query into primitive queries in the context of specified index
*
* @param \ZendSearch\Lucene\SearchIndexInterface $index
* @throws \ZendSearch\Lucene\Search\Exception\QueryParserException
* @return \ZendSearch\Lucene\Search\Query\AbstractQuery
*/
public function rewrite(Lucene\SearchIndexInterface $index)
{
if ($this->_field === null) {
$query = new Query\MultiTerm();
$query->setBoost($this->getBoost());
$hasInsignificantSubqueries = false;
if (Lucene\Lucene::getDefaultSearchField() === null) {
$searchFields = $index->getFieldNames(true);
} else {
$searchFields = array(Lucene\Lucene::getDefaultSearchField());
}
foreach ($searchFields as $fieldName) {
$subquery = new Term($this->_word, $this->_encoding, $fieldName);
$rewrittenSubquery = $subquery->rewrite($index);
foreach ($rewrittenSubquery->getQueryTerms() as $term) {
$query->addTerm($term);
}
if ($rewrittenSubquery instanceof Query\Insignificant) {
$hasInsignificantSubqueries = true;
}
}
if (count($query->getTerms()) == 0) {
$this->_matches = array();
if ($hasInsignificantSubqueries) {
return new Query\Insignificant();
} else {
return new Query\EmptyResult();
}
}
$this->_matches = $query->getQueryTerms();
return $query;
}
// -------------------------------------
// Recognize exact term matching (it corresponds to Keyword fields stored in the index)
// encoding is not used since we expect binary matching
$term = new Index\Term($this->_word, $this->_field);
if ($index->hasTerm($term)) {
$query = new Query\Term($term);
$query->setBoost($this->getBoost());
$this->_matches = $query->getQueryTerms();
return $query;
}
// -------------------------------------
// Recognize wildcard queries
/**
* @todo check for PCRE unicode support may be performed through Zend_Environment in some future
*/
ErrorHandler::start(E_WARNING);
$result = preg_match('/\\pL/u', 'a');
ErrorHandler::stop();
if ($result == 1) {
$word = iconv($this->_encoding, 'UTF-8', $this->_word);
$wildcardsPattern = '/[*?]/u';
$subPatternsEncoding = 'UTF-8';
} else {
$word = $this->_word;
$wildcardsPattern = '/[*?]/';
$subPatternsEncoding = $this->_encoding;
}
$subPatterns = preg_split($wildcardsPattern, $word, -1, PREG_SPLIT_OFFSET_CAPTURE);
if (count($subPatterns) > 1) {
// Wildcard query is recognized
$pattern = '';
foreach ($subPatterns as $id => $subPattern) {
// Append corresponding wildcard character to the pattern before each sub-pattern (except first)
if ($id != 0) {
$pattern .= $word[$subPattern[1] - 1];
}
// Check if each subputtern is a single word in terms of current analyzer
$tokens = Analyzer\Analyzer::getDefault()->tokenize($subPattern[0], $subPatternsEncoding);
if (count($tokens) > 1) {
throw new QueryParserException('Wildcard search is supported only for non-multiple word terms');
}
foreach ($tokens as $token) {
$pattern .= $token->getTermText();
}
}
$term = new Index\Term($pattern, $this->_field);
$query = new Query\Wildcard($term);
$query->setBoost($this->getBoost());
// Get rewritten query. Important! It also fills terms matching container.
$rewrittenQuery = $query->rewrite($index);
$this->_matches = $query->getQueryTerms();
return $rewrittenQuery;
}
// -------------------------------------
// Recognize one-term multi-term and "insignificant" queries
$tokens = Analyzer\Analyzer::getDefault()->tokenize($this->_word, $this->_encoding);
if (count($tokens) == 0) {
$this->_matches = array();
return new Query\Insignificant();
}
if (count($tokens) == 1) {
$term = new Index\Term($tokens[0]->getTermText(), $this->_field);
$query = new Query\Term($term);
$query->setBoost($this->getBoost());
$this->_matches = $query->getQueryTerms();
return $query;
}
//It's not insignificant or one term query
$query = new Query\MultiTerm();
/**
* @todo Process $token->getPositionIncrement() to support stemming, synonyms and other
* analizer design features
*/
foreach ($tokens as $token) {
$term = new Index\Term($token->getTermText(), $this->_field);
$query->addTerm($term, true);
// all subterms are required
}
$query->setBoost($this->getBoost());
$this->_matches = $query->getQueryTerms();
return $query;
}
/**
* Re-write query into primitive queries in the context of specified index
*
* @param \ZendSearch\Lucene\SearchIndexInterface $index
* @return \ZendSearch\Lucene\Search\Query\AbstractQuery
*/
public function rewrite(Lucene\SearchIndexInterface $index)
{
// Allow to use wildcards within phrases
// They are either removed by text analyzer or used as a part of keyword for keyword fields
//
// if (strpos($this->_phrase, '?') !== false || strpos($this->_phrase, '*') !== false) {
// require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
// throw new Zend_Search_Lucene_Search_QueryParserException('Wildcards are only allowed in a single terms.');
// }
// Split query into subqueries if field name is not specified
if ($this->_field === null) {
$query = new Query\Boolean();
$query->setBoost($this->getBoost());
if (Lucene\Lucene::getDefaultSearchField() === null) {
$searchFields = $index->getFieldNames(true);
} else {
$searchFields = array(Lucene\Lucene::getDefaultSearchField());
}
foreach ($searchFields as $fieldName) {
$subquery = new Phrase($this->_phrase, $this->_phraseEncoding, $fieldName);
$subquery->setSlop($this->getSlop());
$query->addSubquery($subquery->rewrite($index));
}
$this->_matches = $query->getQueryTerms();
return $query;
}
// Recognize exact term matching (it corresponds to Keyword fields stored in the index)
// encoding is not used since we expect binary matching
$term = new Index\Term($this->_phrase, $this->_field);
if ($index->hasTerm($term)) {
$query = new Query\Term($term);
$query->setBoost($this->getBoost());
$this->_matches = $query->getQueryTerms();
return $query;
}
// tokenize phrase using current analyzer and process it as a phrase query
$tokens = Analyzer::getDefault()->tokenize($this->_phrase, $this->_phraseEncoding);
if (count($tokens) == 0) {
$this->_matches = array();
return new Query\Insignificant();
}
if (count($tokens) == 1) {
$term = new Index\Term($tokens[0]->getTermText(), $this->_field);
$query = new Query\Term($term);
$query->setBoost($this->getBoost());
$this->_matches = $query->getQueryTerms();
return $query;
}
//It's non-trivial phrase query
$position = -1;
$query = new Query\Phrase();
foreach ($tokens as $token) {
$position += $token->getPositionIncrement();
$term = new Index\Term($token->getTermText(), $this->_field);
$query->addTerm($term, $position);
$query->setSlop($this->getSlop());
}
$this->_matches = $query->getQueryTerms();
return $query;
}
/**
* Re-write query into primitive queries in the context of specified index
*
* @param \ZendSearch\Lucene\SearchIndexInterface $index
* @throws \ZendSearch\Lucene\Search\Exception\QueryParserException
* @return \ZendSearch\Lucene\Search\Query\AbstractQuery
*/
public function rewrite(Lucene\SearchIndexInterface $index)
{
if ($this->_field === null) {
$query = new Search\Query\Boolean();
$hasInsignificantSubqueries = false;
if (Lucene\Lucene::getDefaultSearchField() === null) {
$searchFields = $index->getFieldNames(true);
} else {
$searchFields = array(Lucene\Lucene::getDefaultSearchField());
}
foreach ($searchFields as $fieldName) {
$subquery = new self($this->_word, $this->_encoding, $fieldName, $this->_minimumSimilarity);
$rewrittenSubquery = $subquery->rewrite($index);
if (!($rewrittenSubquery instanceof Query\Insignificant || $rewrittenSubquery instanceof Query\EmptyResult)) {
$query->addSubquery($rewrittenSubquery);
}
if ($rewrittenSubquery instanceof Query\Insignificant) {
$hasInsignificantSubqueries = true;
}
}
$subqueries = $query->getSubqueries();
if (count($subqueries) == 0) {
$this->_matches = array();
if ($hasInsignificantSubqueries) {
return new Query\Insignificant();
} else {
return new Query\EmptyResult();
}
}
if (count($subqueries) == 1) {
$query = reset($subqueries);
}
$query->setBoost($this->getBoost());
$this->_matches = $query->getQueryTerms();
return $query;
}
// -------------------------------------
// Recognize exact term matching (it corresponds to Keyword fields stored in the index)
// encoding is not used since we expect binary matching
$term = new Index\Term($this->_word, $this->_field);
if ($index->hasTerm($term)) {
$query = new Query\Fuzzy($term, $this->_minimumSimilarity);
$query->setBoost($this->getBoost());
// Get rewritten query. Important! It also fills terms matching container.
$rewrittenQuery = $query->rewrite($index);
$this->_matches = $query->getQueryTerms();
return $rewrittenQuery;
}
// -------------------------------------
// Recognize wildcard queries
/**
* @todo check for PCRE unicode support may be performed through Zend_Environment in some future
*/
ErrorHandler::start(E_WARNING);
$result = preg_match('/\\pL/u', 'a');
ErrorHandler::stop();
if ($result == 1) {
$subPatterns = preg_split('/[*?]/u', iconv($this->_encoding, 'UTF-8', $this->_word));
} else {
$subPatterns = preg_split('/[*?]/', $this->_word);
}
if (count($subPatterns) > 1) {
throw new QueryParserException('Fuzzy search doesn\'t support wildcards (except within Keyword fields).');
}
// -------------------------------------
// Recognize one-term multi-term and "insignificant" queries
$tokens = Analyzer\Analyzer::getDefault()->tokenize($this->_word, $this->_encoding);
if (count($tokens) == 0) {
$this->_matches = array();
return new Query\Insignificant();
}
if (count($tokens) == 1) {
$term = new Index\Term($tokens[0]->getTermText(), $this->_field);
$query = new Query\Fuzzy($term, $this->_minimumSimilarity);
$query->setBoost($this->getBoost());
// Get rewritten query. Important! It also fills terms matching container.
$rewrittenQuery = $query->rewrite($index);
$this->_matches = $query->getQueryTerms();
return $rewrittenQuery;
}
// Word is tokenized into several tokens
throw new QueryParserException('Fuzzy search is supported only for non-multiple word terms');
}
