PHP Lucene::getDefaultSearchField方法代码示例

 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);
 }

 /**
  * Object constructor
  */
 public function __construct($text, $field = null)
 {
     $this->field = ($field === null)?  Lucene\Lucene::getDefaultSearchField() : $field;
     $this->text  = $text;
 }

 public function testDefaultSearchField()
 {
     $index = Lucene\Lucene::open(dirname(__FILE__) . '/_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);
 }

 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\SearchIndexInterface $index
  * @return \Zend\Search\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 \Zend\Search\Lucene\SearchIndex $index
  * @throws \Zend\Search\Lucence\Search\Exception\QueryParserException
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  */
 public function rewrite(Lucene\SearchIndex $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 */
     if (@preg_match('/\\pL/u', 'a') == 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;
//.........这里部分代码省略.........

 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\SearchIndex $index
  * @throws \Zend\Search\Lucence\Search\Exception\QueryParserException
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  */
 public function rewrite(Lucene\SearchIndex $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 */
     if (@preg_match('/\\pL/u', 'a') == 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');
 }