예제 #1
0
파일: Phrase.php 프로젝트: stunti/zf2
 /**
  * The sum of squared weights of contained query clauses.
  *
  * @return float
  */
 public function sumOfSquaredWeights()
 {
     // compute idf
     $this->_idf = $this->_reader->getSimilarity()->idf($this->_query->getTerms(), $this->_reader);
     // compute query weight
     $this->_queryWeight = $this->_idf * $this->_query->getBoost();
     // square it
     return $this->_queryWeight * $this->_queryWeight;
 }
예제 #2
0
파일: QueryHit.php 프로젝트: stunti/zf2
 /**
  * Return the document object for this hit
  *
  * @return \Zend\Search\Lucene\Document\Document
  */
 public function getDocument()
 {
     if (!$this->_document instanceof Document\Document) {
         $this->_document = $this->_index->getDocument($this->id);
     }
     return $this->_document;
 }
예제 #3
0
파일: Fuzzy.php 프로젝트: stunti/zf2
 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\IndexInterface $index
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  * @throws \Zend\Search\Lucene\Exception
  */
 public function rewrite(Lucene\IndexInterface $index)
 {
     $this->_matches = array();
     $this->_scores = array();
     $this->_termKeys = array();
     if ($this->_term->field === null) {
         // Search through all fields
         $fields = $index->getFieldNames(true);
     } else {
         $fields = array($this->_term->field);
     }
     $prefix = Index\Term::getPrefix($this->_term->text, $this->_prefixLength);
     $prefixByteLength = strlen($prefix);
     $prefixUtf8Length = Index\Term::getLength($prefix);
     $termLength = Index\Term::getLength($this->_term->text);
     $termRest = substr($this->_term->text, $prefixByteLength);
     // we calculate length of the rest in bytes since levenshtein() is not UTF-8 compatible
     $termRestLength = strlen($termRest);
     $scaleFactor = 1 / (1 - $this->_minimumSimilarity);
     $maxTerms = Lucene\Lucene::getTermsPerQueryLimit();
     foreach ($fields as $field) {
         $index->resetTermsStream();
         if ($prefix != '') {
             $index->skipTo(new Index\Term($prefix, $field));
             while ($index->currentTerm() !== null && $index->currentTerm()->field == $field && substr($index->currentTerm()->text, 0, $prefixByteLength) == $prefix) {
                 // Calculate similarity
                 $target = substr($index->currentTerm()->text, $prefixByteLength);
                 $maxDistance = isset($this->_maxDistances[strlen($target)]) ? $this->_maxDistances[strlen($target)] : $this->_calculateMaxDistance($prefixUtf8Length, $termRestLength, strlen($target));
                 if ($termRestLength == 0) {
                     // we don't have anything to compare.  That means if we just add
                     // the letters for current term we get the new word
                     $similarity = $prefixUtf8Length == 0 ? 0 : 1 - strlen($target) / $prefixUtf8Length;
                 } else {
                     if (strlen($target) == 0) {
                         $similarity = $prefixUtf8Length == 0 ? 0 : 1 - $termRestLength / $prefixUtf8Length;
                     } else {
                         if ($maxDistance < abs($termRestLength - strlen($target))) {
                             //just adding the characters of term to target or vice-versa results in too many edits
                             //for example "pre" length is 3 and "prefixes" length is 8.  We can see that
                             //given this optimal circumstance, the edit distance cannot be less than 5.
                             //which is 8-3 or more precisesly abs(3-8).
                             //if our maximum edit distance is 4, then we can discard this word
                             //without looking at it.
                             $similarity = 0;
                         } else {
                             $similarity = 1 - levenshtein($termRest, $target) / ($prefixUtf8Length + min($termRestLength, strlen($target)));
                         }
                     }
                 }
                 if ($similarity > $this->_minimumSimilarity) {
                     $this->_matches[] = $index->currentTerm();
                     $this->_termKeys[] = $index->currentTerm()->key();
                     $this->_scores[] = ($similarity - $this->_minimumSimilarity) * $scaleFactor;
                     if ($maxTerms != 0 && count($this->_matches) > $maxTerms) {
                         throw new Lucene\Exception('Terms per query limit is reached.');
                     }
                 }
                 $index->nextTerm();
             }
         } else {
             $index->skipTo(new Index\Term('', $field));
             while ($index->currentTerm() !== null && $index->currentTerm()->field == $field) {
                 // Calculate similarity
                 $target = $index->currentTerm()->text;
                 $maxDistance = isset($this->_maxDistances[strlen($target)]) ? $this->_maxDistances[strlen($target)] : $this->_calculateMaxDistance(0, $termRestLength, strlen($target));
                 if ($maxDistance < abs($termRestLength - strlen($target))) {
                     //just adding the characters of term to target or vice-versa results in too many edits
                     //for example "pre" length is 3 and "prefixes" length is 8.  We can see that
                     //given this optimal circumstance, the edit distance cannot be less than 5.
                     //which is 8-3 or more precisesly abs(3-8).
                     //if our maximum edit distance is 4, then we can discard this word
                     //without looking at it.
                     $similarity = 0;
                 } else {
                     $similarity = 1 - levenshtein($termRest, $target) / min($termRestLength, strlen($target));
                 }
                 if ($similarity > $this->_minimumSimilarity) {
                     $this->_matches[] = $index->currentTerm();
                     $this->_termKeys[] = $index->currentTerm()->key();
                     $this->_scores[] = ($similarity - $this->_minimumSimilarity) * $scaleFactor;
                     if ($maxTerms != 0 && count($this->_matches) > $maxTerms) {
                         throw new Lucene\Exception('Terms per query limit is reached.');
                     }
                 }
                 $index->nextTerm();
             }
         }
         $index->closeTermsStream();
     }
     if (count($this->_matches) == 0) {
         return new EmptyResult();
     } else {
         if (count($this->_matches) == 1) {
             return new Term(reset($this->_matches));
         } else {
             $rewrittenQuery = new Boolean();
             array_multisort($this->_scores, SORT_DESC, SORT_NUMERIC, $this->_termKeys, SORT_ASC, SORT_STRING, $this->_matches);
             $termCount = 0;
             foreach ($this->_matches as $id => $matchedTerm) {
                 $subquery = new Term($matchedTerm);
                 $subquery->setBoost($this->_scores[$id]);
                 $rewrittenQuery->addSubquery($subquery);
                 $termCount++;
                 if ($termCount >= self::MAX_CLAUSE_COUNT) {
                     break;
                 }
             }
             return $rewrittenQuery;
         }
     }
 }
예제 #4
0
파일: Phrase.php 프로젝트: stunti/zf2
 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\IndexInterface $index
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  */
 public function rewrite(Lucene\IndexInterface $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\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;
 }
예제 #5
0
파일: Term.php 프로젝트: stunti/zf2
 /**
  * Score specified document
  *
  * @param integer $docId
  * @param \Zend\Search\Lucene\IndexInterface $reader
  * @return float
  */
 public function score($docId, Lucene\IndexInterface $reader)
 {
     if (isset($this->_docVector[$docId])) {
         return $reader->getSimilarity()->tf($this->_termFreqs[$docId]) * $this->_weight->getValue() * $reader->norm($docId, $this->_term->field) * $this->getBoost();
     } else {
         return 0;
     }
 }
예제 #6
0
파일: Boolean.php 프로젝트: stunti/zf2
 /**
  * Score calculator for non conjunction queries (not all subqueries are required)
  *
  * @param integer $docId
  * @param \Zend\Search\Lucene\IndexInterface $reader
  * @return float
  */
 public function _nonConjunctionScore($docId, Lucene\IndexInterface $reader)
 {
     if ($this->_coord === null) {
         $this->_coord = array();
         $maxCoord = 0;
         foreach ($this->_signs as $sign) {
             if ($sign !== false) {
                 $maxCoord++;
             }
         }
         for ($count = 0; $count <= $maxCoord; $count++) {
             $this->_coord[$count] = $reader->getSimilarity()->coord($count, $maxCoord);
         }
     }
     $score = 0;
     $matchedSubqueries = 0;
     foreach ($this->_subqueries as $subqueryId => $subquery) {
         $subscore = $subquery->score($docId, $reader);
         // Prohibited
         if ($this->_signs[$subqueryId] === false && $subscore != 0) {
             return 0;
         }
         // is required, but doen't match
         if ($this->_signs[$subqueryId] === true && $subscore == 0) {
             return 0;
         }
         if ($subscore != 0) {
             $matchedSubqueries++;
             $score += $subscore;
         }
     }
     return $score * $this->_coord[$matchedSubqueries] * $this->getBoost();
 }
예제 #7
0
파일: Range.php 프로젝트: stunti/zf2
 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\IndexInterface $index
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  */
 public function rewrite(Lucene\IndexInterface $index)
 {
     $this->_matches = array();
     if ($this->_field === null) {
         // Search through all fields
         $fields = $index->getFieldNames(true);
     } else {
         $fields = array($this->_field);
     }
     $maxTerms = Lucene\Lucene::getTermsPerQueryLimit();
     foreach ($fields as $field) {
         $index->resetTermsStream();
         if ($this->_lowerTerm !== null) {
             $lowerTerm = new Index\Term($this->_lowerTerm->text, $field);
             $index->skipTo($lowerTerm);
             if (!$this->_inclusive && $index->currentTerm() == $lowerTerm) {
                 // Skip lower term
                 $index->nextTerm();
             }
         } else {
             $index->skipTo(new Index\Term('', $field));
         }
         if ($this->_upperTerm !== null) {
             // Walk up to the upper term
             $upperTerm = new Index\Term($this->_upperTerm->text, $field);
             while ($index->currentTerm() !== null && $index->currentTerm()->field == $field && $index->currentTerm()->text < $upperTerm->text) {
                 $this->_matches[] = $index->currentTerm();
                 if ($maxTerms != 0 && count($this->_matches) > $maxTerms) {
                     throw new Lucene\Exception('Terms per query limit is reached.');
                 }
                 $index->nextTerm();
             }
             if ($this->_inclusive && $index->currentTerm() == $upperTerm) {
                 // Include upper term into result
                 $this->_matches[] = $upperTerm;
             }
         } else {
             // Walk up to the end of field data
             while ($index->currentTerm() !== null && $index->currentTerm()->field == $field) {
                 $this->_matches[] = $index->currentTerm();
                 if ($maxTerms != 0 && count($this->_matches) > $maxTerms) {
                     throw new Lucene\Exception('Terms per query limit is reached.');
                 }
                 $index->nextTerm();
             }
         }
         $index->closeTermsStream();
     }
     if (count($this->_matches) == 0) {
         return new EmptyResult();
     } else {
         if (count($this->_matches) == 1) {
             return new Term(reset($this->_matches));
         } else {
             $rewrittenQuery = new MultiTerm();
             foreach ($this->_matches as $matchedTerm) {
                 $rewrittenQuery->addTerm($matchedTerm);
             }
             return $rewrittenQuery;
         }
     }
 }
예제 #8
0
파일: Term.php 프로젝트: stunti/zf2
 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\IndexInterface $index
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  */
 public function rewrite(Lucene\IndexInterface $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;
     }
     //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;
 }
예제 #9
0
파일: Wildcard.php 프로젝트: stunti/zf2
 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\IndexInterface $index
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  * @throws \Zend\Search\Lucene\Exception
  */
 public function rewrite(Lucene\IndexInterface $index)
 {
     $this->_matches = array();
     if ($this->_pattern->field === null) {
         // Search through all fields
         $fields = $index->getFieldNames(true);
     } else {
         $fields = array($this->_pattern->field);
     }
     $prefix = self::_getPrefix($this->_pattern->text);
     $prefixLength = strlen($prefix);
     $matchExpression = '/^' . str_replace(array('\\?', '\\*'), array('.', '.*'), preg_quote($this->_pattern->text, '/')) . '$/';
     if ($prefixLength < self::$_minPrefixLength) {
         throw new Lucene\Exception('At least ' . self::$_minPrefixLength . ' non-wildcard characters are required at the beginning of pattern.');
     }
     /** @todo check for PCRE unicode support may be performed through Zend_Environment in some future */
     if (@preg_match('/\\pL/u', 'a') == 1) {
         // PCRE unicode support is turned on
         // add Unicode modifier to the match expression
         $matchExpression .= 'u';
     }
     $maxTerms = Lucene\Lucene::getTermsPerQueryLimit();
     foreach ($fields as $field) {
         $index->resetTermsStream();
         if ($prefix != '') {
             $index->skipTo(new Index\Term($prefix, $field));
             while ($index->currentTerm() !== null && $index->currentTerm()->field == $field && substr($index->currentTerm()->text, 0, $prefixLength) == $prefix) {
                 if (preg_match($matchExpression, $index->currentTerm()->text) === 1) {
                     $this->_matches[] = $index->currentTerm();
                     if ($maxTerms != 0 && count($this->_matches) > $maxTerms) {
                         throw new Lucene\Exception('Terms per query limit is reached.');
                     }
                 }
                 $index->nextTerm();
             }
         } else {
             $index->skipTo(new Index\Term('', $field));
             while ($index->currentTerm() !== null && $index->currentTerm()->field == $field) {
                 if (preg_match($matchExpression, $index->currentTerm()->text) === 1) {
                     $this->_matches[] = $index->currentTerm();
                     if ($maxTerms != 0 && count($this->_matches) > $maxTerms) {
                         throw new Lucene\Exception('Terms per query limit is reached.');
                     }
                 }
                 $index->nextTerm();
             }
         }
         $index->closeTermsStream();
     }
     if (count($this->_matches) == 0) {
         return new EmptyResult();
     } else {
         if (count($this->_matches) == 1) {
             return new Term(reset($this->_matches));
         } else {
             $rewrittenQuery = new MultiTerm();
             foreach ($this->_matches as $matchedTerm) {
                 $rewrittenQuery->addTerm($matchedTerm);
             }
             return $rewrittenQuery;
         }
     }
 }
예제 #10
0
파일: Phrase.php 프로젝트: stunti/zf2
 /**
  * Execute query in context of index reader
  * It also initializes necessary internal structures
  *
  * @param \Zend\Search\Lucene\IndexInterface $reader
  * @param \Zend\Search\Lucene\Index\DocsFilter|null $docsFilter
  */
 public function execute(Lucene\IndexInterface $reader, $docsFilter = null)
 {
     $this->_resVector = null;
     if (count($this->_terms) == 0) {
         $this->_resVector = array();
     }
     $resVectors = array();
     $resVectorsSizes = array();
     $resVectorsIds = array();
     // is used to prevent arrays comparison
     foreach ($this->_terms as $termId => $term) {
         $resVectors[] = array_flip($reader->termDocs($term));
         $resVectorsSizes[] = count(end($resVectors));
         $resVectorsIds[] = $termId;
         $this->_termsPositions[$termId] = $reader->termPositions($term);
     }
     // sort resvectors in order of subquery cardinality increasing
     array_multisort($resVectorsSizes, SORT_ASC, SORT_NUMERIC, $resVectorsIds, SORT_ASC, SORT_NUMERIC, $resVectors);
     foreach ($resVectors as $nextResVector) {
         if ($this->_resVector === null) {
             $this->_resVector = $nextResVector;
         } else {
             //$this->_resVector = array_intersect_key($this->_resVector, $nextResVector);
             /**
              * This code is used as workaround for array_intersect_key() slowness problem.
              */
             $updatedVector = array();
             foreach ($this->_resVector as $id => $value) {
                 if (isset($nextResVector[$id])) {
                     $updatedVector[$id] = $value;
                 }
             }
             $this->_resVector = $updatedVector;
         }
         if (count($this->_resVector) == 0) {
             // Empty result set, we don't need to check other terms
             break;
         }
     }
     // ksort($this->_resVector, SORT_NUMERIC);
     // Docs are returned ordered. Used algorithm doesn't change elements order.
     // Initialize weight if it's not done yet
     $this->_initWeight($reader);
 }
예제 #11
0
 /**
  * Computes a score factor for a simple term or a phrase.
  *
  * The default implementation is:
  *   return idfFreq(searcher.docFreq(term), searcher.maxDoc());
  *
  * input - the term in question or array of terms
  * reader - reader the document collection being searched
  * Returns a score factor for the term
  *
  * @param mixed $input
  * @param \Zend\Search\Lucene\IndexInterface $reader
  * @return a score factor for the term
  */
 public function idf($input, \Zend\Search\Lucene\IndexInterface $reader)
 {
     if (!is_array($input)) {
         return $this->idfFreq($reader->docFreq($input), $reader->count());
     } else {
         $idf = 0.0;
         foreach ($input as $term) {
             $idf += $this->idfFreq($reader->docFreq($term), $reader->count());
         }
         return $idf;
     }
 }
예제 #12
0
파일: MultiTerm.php 프로젝트: stunti/zf2
 /**
  * Score calculator for non conjunction queries (not all terms are required)
  *
  * @param integer $docId
  * @param \Zend\Search\Lucene\IndexInterface $reader
  * @return float
  */
 public function _nonConjunctionScore($docId, $reader)
 {
     if ($this->_coord === null) {
         $this->_coord = array();
         $maxCoord = 0;
         foreach ($this->_signs as $sign) {
             if ($sign !== false) {
                 $maxCoord++;
             }
         }
         for ($count = 0; $count <= $maxCoord; $count++) {
             $this->_coord[$count] = $reader->getSimilarity()->coord($count, $maxCoord);
         }
     }
     $score = 0.0;
     $matchedTerms = 0;
     foreach ($this->_terms as $termId => $term) {
         // Check if term is
         if ($this->_signs[$termId] !== false && isset($this->_termsFreqs[$termId][$docId])) {
             $matchedTerms++;
             /**
              * We don't need to check that term freq is not 0
              * Score calculation is performed only for matched docs
              */
             $score += $reader->getSimilarity()->tf($this->_termsFreqs[$termId][$docId]) * $this->_weights[$termId]->getValue() * $reader->norm($docId, $term->field);
         }
     }
     return $score * $this->_coord[$matchedTerms] * $this->getBoost();
 }
예제 #13
0
파일: Fuzzy.php 프로젝트: stunti/zf2
 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\IndexInterface $index
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  */
 public function rewrite(Lucene\IndexInterface $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 Search\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 Search\QueryParserException('Fuzzy search is supported only for non-multiple word terms');
 }