public function rewrite(Zend_Search_Lucene_Interface $index)
 {
     if (count($this->_terms) == 0) {
         return new Zend_Search_Lucene_Search_Query_Empty();
     }
     // Check, that all fields are qualified
     $allQualified = true;
     foreach ($this->_terms as $term) {
         if ($term->field === null) {
             $allQualified = false;
             break;
         }
     }
     if ($allQualified) {
         return $this;
     } else {
         $query = new Zend_Search_Lucene_Search_Query_Boolean();
         $query->setBoost($this->getBoost());
         foreach ($this->_terms as $termId => $term) {
             $subquery = new Zend_Search_Lucene_Search_Query_Term($term);
             $query->addSubquery($subquery->rewrite($index), $this->_signs === null ? true : $this->_signs[$termId]);
         }
         return $query;
     }
 }

 public function execute($request)
 {
     if (!isset($request->limit)) {
         $request->limit = sfConfig::get('app_hits_per_page');
     }
     $this->resource = $this->getRoute()->resource;
     // Check that this isn't the root
     if (!isset($this->resource->parent)) {
         $this->forward404();
     }
     $search = new QubitSearch();
     $query = new Zend_Search_Lucene_Search_Query_Boolean();
     $query->addSubquery(new Zend_Search_Lucene_Search_Query_Term(new Zend_Search_Lucene_Index_Term($this->resource->id, 'parentId')), true);
     if (isset($request->query)) {
         $query = $request->query;
     }
     $query = QubitAcl::searchFilterByRepository($query, 'read');
     $query = QubitAcl::searchFilterDrafts($query);
     $this->pager = new QubitArrayPager();
     $this->pager->hits = $search->getEngine()->getIndex()->find($query);
     $this->pager->setMaxPerPage($request->limit);
     $this->pager->setPage($request->page);
     $ids = array();
     foreach ($this->pager->getResults() as $hit) {
         $ids[] = $hit->getDocument()->id;
     }
     $criteria = new Criteria();
     $criteria->add(QubitInformationObject::ID, $ids, Criteria::IN);
     $this->informationObjects = QubitInformationObject::get($criteria);
 }

 public function searchAction()
 {
     $filters = array('q' => array('StringTrim', 'StripTags'));
     $validators = array('q' => array('presence' => 'required'));
     $input = new Zend_Filter_Input($filters, $validators, $_GET);
     if (is_string($this->_request->getParam('q'))) {
         $queryString = $input->getEscaped('q');
         $this->view->queryString = $queryString;
         if ($input->isValid()) {
             $config = Zend_Registry::get('config');
             $index = App_Search_Lucene::open($config->luceneIndex);
             $query = new Zend_Search_Lucene_Search_Query_Boolean();
             $pathTerm = new Zend_Search_Lucene_Index_Term($queryString);
             $pathQuery = new Zend_Search_Lucene_Search_Query_Term($pathTerm);
             $query->addSubquery($pathQuery, true);
             $pathTerm = new Zend_Search_Lucene_Index_Term('20091023', 'CreationDate');
             $pathQuery = new Zend_Search_Lucene_Search_Query_Term($pathTerm);
             $query->addSubquery($pathQuery, true);
             try {
                 $hits = $index->find($query);
             } catch (Zend_Search_Lucene_Exception $ex) {
                 $hits = array();
             }
             $this->view->hits = $hits;
         } else {
             $this->view->messages = $input->getMessages();
         }
     }
 }

 /**
  * Generates a Lucene object from the expression objects.
  *
  * @param array $names Associative list of variable or column names as keys and their corresponding types
  * @param array $translations Associative list of variable or column names that should be translated
  * @param array $plugins Associative list of item names and plugins implementing MW_Common_Criteria_Plugin_Interface
  * @return Zend_Search_Lucene_Search_Query_MultiTerm Combined search objects
  */
 public function toString(array $types, array $translations = array(), array $plugins = array())
 {
     $query = new Zend_Search_Lucene_Search_Query_Boolean();
     foreach ($this->_expressions as $expr) {
         if (($itemstr = $expr->toString($types, $translations, $plugins)) !== '') {
             $query->addSubquery($itemstr, self::$_operators[$this->_operator]);
         }
     }
     return $query;
 }

 public function generateSitemap()
 {
     $this->prepareSiteMapFolder();
     if (!is_null($this->sitemapDir)) {
         $hosts = $this->getValidHosts();
         if (is_array($hosts)) {
             foreach ($hosts as $hostName) {
                 $query = new \Zend_Search_Lucene_Search_Query_Boolean();
                 $hostTerm = new \Zend_Search_Lucene_Index_Term($hostName, 'host');
                 $hostQuery = new \Zend_Search_Lucene_Search_Query_Term($hostTerm);
                 $query->addSubquery($hostQuery, TRUE);
                 $hostTerm = new \Zend_Search_Lucene_Index_Term(TRUE, 'restrictionGroup_default');
                 $hostQuery = new \Zend_Search_Lucene_Search_Query_Term($hostTerm);
                 $query->addSubquery($hostQuery, TRUE);
                 $hits = $this->index->find($query);
                 $name = str_replace('.', '-', $hostName);
                 $filePath = $this->sitemapDir . '/sitemap-' . $name . '.xml';
                 $fh = fopen($filePath, 'w');
                 fwrite($fh, '<?xml version="1.0" encoding="UTF-8"?>' . "\r\n");
                 fwrite($fh, '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">');
                 fwrite($fh, "\r\n");
                 for ($i = 0; $i < count($hits); $i++) {
                     $url = $hits[$i]->getDocument()->getField('url');
                     $uri = str_replace(array('?pimcore_outputfilters_disabled=1', '&pimcore_outputfilters_disabled=1'), '', $url->value);
                     fwrite($fh, '<url>' . "\r\n");
                     fwrite($fh, '    <loc>' . htmlspecialchars($uri, ENT_QUOTES) . '</loc>' . "\r\n");
                     fwrite($fh, '</url>' . "\r\n");
                 }
                 fwrite($fh, '</urlset>' . "\r\n");
                 fclose($fh);
             }
             $filePath = $this->sitemapDir . '/sitemap.xml';
             $fh = fopen($filePath, 'w');
             fwrite($fh, '<?xml version="1.0" encoding="UTF-8"?>' . "\r\n");
             fwrite($fh, '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">');
             fwrite($fh, "\r\n");
             foreach ($hosts as $hostName) {
                 $name = str_replace('.', '-', $hostName);
                 //first host must be main domain - see hint in plugin settings
                 $currenthost = $hosts[0];
                 fwrite($fh, '<sitemap>' . "\r\n");
                 fwrite($fh, '    <loc>http://' . $currenthost . '/plugin/LuceneSearch/frontend/sitemap/?sitemap=sitemap-' . $name . '.xml' . '</loc>' . "\r\n");
                 fwrite($fh, '</sitemap>' . "\r\n");
                 \Pimcore\Logger::debug('LuceneSearch: ' . $hostName . ' for sitemap.xml added.');
             }
             fwrite($fh, '</sitemapindex>' . "\r\n");
             fclose($fh);
         } else {
             \Pimcore\Logger::debug('LuceneSearch: could not generate sitemaps, did not find any hosts in index.');
         }
     } else {
         \Pimcore\Logger::emerg('LuceneSearch: Cannot generate sitemap. Sitemap directory [ ' . $this->sitemapDir . ' ]  not available/not writeable and cannot be created');
     }
 }

 /**
  * @param $queryString
  * @return array
  */
 public function find($queryString)
 {
     $queryString = trim($queryString);
     if (empty($queryString)) {
         return ["queryString" => $queryString, "message" => "No String"];
     } else {
         $index = \Zend_Search_Lucene::open($this->indexfile);
         $res = explode(' ', $queryString);
         \Zend_Search_Lucene_Search_Query_Wildcard::setMinPrefixLength(1);
         \Zend_Search_Lucene::setResultSetLimit(5);
         $query = new \Zend_Search_Lucene_Search_Query_Boolean();
         foreach ($res as $val) {
             if (!empty($val)) {
                 $subquery = new \Zend_Search_Lucene_Search_Query_Boolean();
                 $searchkey1 = $val . "*";
                 $pattern = new \Zend_Search_Lucene_Index_Term($searchkey1, "name");
                 $userQuery = new \Zend_Search_Lucene_Search_Query_Wildcard($pattern);
                 $patternUsername = new \Zend_Search_Lucene_Index_Term($searchkey1, "username");
                 $usernameQuery = new \Zend_Search_Lucene_Search_Query_Wildcard($patternUsername);
                 $subquery->addSubquery($userQuery, null);
                 $subquery->addSubquery($usernameQuery, null);
                 $query->addSubquery($subquery, true);
             }
         }
         $hits = $index->find($query);
         if (!empty($hits)) {
             $results = [];
             foreach ($hits as $hit) {
                 if ($hit->username != $_SESSION['user']->username) {
                     $results[] = $hit->username;
                 }
             }
             if (!empty($results)) {
                 /** @noinspection PhpUndefinedMethodInspection */
                 /** @var Users $users */
                 $users = $_SESSION['user']->getTable();
                 if (isset($_POST['friends'])) {
                     /** @noinspection PhpUndefinedMethodInspection */
                     $friends = $_SESSION['user']->getFriendList();
                     if (empty($friends)) {
                         return ["queryString" => $queryString, "users" => []];
                     } else {
                         $userresult = $users->getSet($results, 'u.username');
                     }
                 } else {
                     $userresult = $users->getSet($results, "u.username", ["u.userid", "u.username", "u.name"]);
                 }
                 return ["queryString" => $queryString, "users" => $userresult->toArray()];
             }
         }
     }
     return ["queryString" => $queryString];
 }

 public function parseQuery()
 {
     try {
         // Parse query string
         $queryParsed = QubitSearch::getInstance()->parse($this->request->query);
     } catch (Exception $e) {
         $this->error = $e->getMessage();
         return null;
     }
     $query = new Zend_Search_Lucene_Search_Query_Boolean();
     $query->addSubquery($queryParsed, true);
     return $query;
 }

 protected function getLuceneQuery($query)
 {
     $words = str_word_count($query, 1);
     $query = new Zend_Search_Lucene_Search_Query_Boolean();
     foreach ($words as $word) {
         $term = new Zend_Search_Lucene_Index_Term($word);
         $subQuery = new Zend_Search_Lucene_Search_Query_Fuzzy($term, 0.4);
         $query->addSubquery($subQuery, true);
     }
     return $query;
     //  return Zend_Search_Lucene_Search_QueryParser::parse($query);
     //    $term = new Zend_Search_Lucene_Index_Term($query);
     //    return new Zend_Search_Lucene_Search_Query_Fuzzy($term, 0.4);
 }

 function searchDocsByContent($q)
 {
     $hits = array();
     try {
         $this->initLuceneEngine();
         $indexer = $this->zend->get_Zend_Search_Lucene();
         $query = new Zend_Search_Lucene_Search_Query_Boolean();
         $subquery = Zend_Search_Lucene_Search_QueryParser::parse('+(' . $q . ')');
         $query->addSubquery($subquery, true);
         // $query->addSubquery(self::makeTermQuery('object_type', JS_TEXT_DATA), true);
         $hits = $indexer->find($query);
         return $hits;
     } catch (Exception $e) {
         echo $e->getTraceAsString();
     }
     return $hits;
 }

 public function userSearch(Kwf_Component_Data $subroot, $queryString, $offset, $limit, $params = array())
 {
     $index = Kwf_Util_Fulltext_Lucene::getInstance($subroot);
     $error = false;
     $userQuery = false;
     if ($queryString) {
         try {
             $userQuery = Zend_Search_Lucene_Search_QueryParser::parse($queryString);
         } catch (ErrorException $e) {
             //ignore iconv errors that happen with invalid input
         }
     }
     $hits = array();
     if ($userQuery) {
         $query = new Zend_Search_Lucene_Search_Query_Boolean();
         $query->addSubquery($userQuery, true);
         if (isset($params['type'])) {
             $pathTerm = new Zend_Search_Lucene_Index_Term($params['type'], 'type');
             $pathQuery = new Zend_Search_Lucene_Search_Query_Term($pathTerm);
             $query->addSubquery($pathQuery, true);
         }
         $time = microtime(true);
         try {
             $hits = $index->find($query);
         } catch (Zend_Search_Lucene_Exception $e) {
             $error = $subroot->trlKwf('Invalid search terms');
         }
     }
     $ret = array();
     if (count($hits)) {
         $numStart = $offset;
         $numEnd = min(count($hits), $offset + $limit);
         for ($i = $numStart; $i < $numEnd; $i++) {
             $h = $hits[$i];
             $c = Kwf_Component_Data_Root::getInstance()->getComponentById($h->componentId);
             if ($c) {
                 $ret[] = array('data' => $c, 'content' => $h->content);
             }
         }
     }
     return array('error' => $error, 'numHits' => count($hits), 'hits' => $ret);
 }

 protected function prepareLuceneQuery($keyword)
 {
     $keyword = strtolower($keyword);
     $query = new Zend_Search_Lucene_Search_Query_Boolean();
     # multiterm query
     $subquery1 = new Zend_Search_Lucene_Search_Query_MultiTerm();
     foreach (explode(' ', $keyword) as $key) {
         if (!trim($key)) {
             continue;
         }
         $subquery1->addTerm(new Zend_Search_Lucene_Index_Term($key));
     }
     # wildcard query
     Zend_Search_Lucene_Search_Query_Wildcard::setMinPrefixLength(1);
     $tokens = preg_split('/ /', $keyword, -1, PREG_SPLIT_NO_EMPTY);
     $lastWord = trim(array_pop($tokens)) . "*";
     $pattern = new Zend_Search_Lucene_Index_Term($lastWord);
     $subquery2 = new Zend_Search_Lucene_Search_Query_Wildcard($pattern);
     $query->addSubquery($subquery1);
     $query->addSubquery($subquery2);
     return $query;
 }

 public function rewrite(Zend_Search_Lucene_Interface $index)
 {
     if (count($this->_terms) == 0) {
         return new Zend_Search_Lucene_Search_Query_Empty();
     } else {
         if ($this->_terms[0]->field !== null) {
             return $this;
         } else {
             $query = new Zend_Search_Lucene_Search_Query_Boolean();
             $query->setBoost($this->getBoost());
             foreach ($index->getFieldNames(true) as $fieldName) {
                 $subquery = new Zend_Search_Lucene_Search_Query_Phrase();
                 $subquery->setSlop($this->getSlop());
                 foreach ($this->_terms as $termId => $term) {
                     $qualifiedTerm = new Zend_Search_Lucene_Index_Term($term->text, $fieldName);
                     $subquery->addTerm($qualifiedTerm, $this->_offsets[$termId]);
                 }
                 $query->addSubquery($subquery);
             }
             return $query;
         }
     }
 }

 /**
  * Generate 'boolean style' query from the context
  * 'term1 and term2   or   term3 and (<subquery1>) and not (<subquery2>)'
  *
  * @return Zend_Search_Lucene_Search_Query
  * @throws Zend_Search_Lucene
  */
 private function _booleanExpressionQuery()
 {
     /**
      * We treat each level of an expression as a boolean expression in
      * a Disjunctive Normal Form
      *
      * AND operator has higher precedence than OR
      *
      * Thus logical query is a disjunction of one or more conjunctions of
      * one or more query entries
      */
     require_once 'Zend/Search/Lucene/Search/BooleanExpressionRecognizer.php';
     $expressionRecognizer = new Zend_Search_Lucene_Search_BooleanExpressionRecognizer();
     require_once 'Zend/Search/Lucene/Exception.php';
     try {
         foreach ($this->_entries as $entry) {
             if ($entry instanceof Zend_Search_Lucene_Search_QueryEntry) {
                 $expressionRecognizer->processLiteral($entry);
             } else {
                 switch ($entry) {
                     case Zend_Search_Lucene_Search_QueryToken::TT_AND_LEXEME:
                         $expressionRecognizer->processOperator(Zend_Search_Lucene_Search_BooleanExpressionRecognizer::IN_AND_OPERATOR);
                         break;
                     case Zend_Search_Lucene_Search_QueryToken::TT_OR_LEXEME:
                         $expressionRecognizer->processOperator(Zend_Search_Lucene_Search_BooleanExpressionRecognizer::IN_OR_OPERATOR);
                         break;
                     case Zend_Search_Lucene_Search_QueryToken::TT_NOT_LEXEME:
                         $expressionRecognizer->processOperator(Zend_Search_Lucene_Search_BooleanExpressionRecognizer::IN_NOT_OPERATOR);
                         break;
                     default:
                         throw new Zend_Search_Lucene('Boolean expression error. Unknown operator type.');
                 }
             }
         }
         $conjuctions = $expressionRecognizer->finishExpression();
     } catch (Zend_Search_Exception $e) {
         // throw new Zend_Search_Lucene_Search_QueryParserException('Boolean expression error. Error message: \'' .
         //                                                          $e->getMessage() . '\'.' );
         // It's query syntax error message and it should be user friendly. So FSM message is omitted
         require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
         throw new Zend_Search_Lucene_Search_QueryParserException('Boolean expression error.', 0, $e);
     }
     // Remove 'only negative' conjunctions
     foreach ($conjuctions as $conjuctionId => $conjuction) {
         $nonNegativeEntryFound = false;
         foreach ($conjuction as $conjuctionEntry) {
             if ($conjuctionEntry[1]) {
                 $nonNegativeEntryFound = true;
                 break;
             }
         }
         if (!$nonNegativeEntryFound) {
             unset($conjuctions[$conjuctionId]);
         }
     }
     $subqueries = array();
     foreach ($conjuctions as $conjuction) {
         // Check, if it's a one term conjuction
         if (count($conjuction) == 1) {
             $subqueries[] = $conjuction[0][0]->getQuery($this->_encoding);
         } else {
             require_once 'Zend/Search/Lucene/Search/Query/Boolean.php';
             $subquery = new Zend_Search_Lucene_Search_Query_Boolean();
             foreach ($conjuction as $conjuctionEntry) {
                 $subquery->addSubquery($conjuctionEntry[0]->getQuery($this->_encoding), $conjuctionEntry[1]);
             }
             $subqueries[] = $subquery;
         }
     }
     if (count($subqueries) == 0) {
         require_once 'Zend/Search/Lucene/Search/Query/Insignificant.php';
         return new Zend_Search_Lucene_Search_Query_Insignificant();
     }
     if (count($subqueries) == 1) {
         return $subqueries[0];
     }
     require_once 'Zend/Search/Lucene/Search/Query/Boolean.php';
     $query = new Zend_Search_Lucene_Search_Query_Boolean();
     foreach ($subqueries as $subquery) {
         // Non-requirered entry/subquery
         $query->addSubquery($subquery);
     }
     return $query;
 }

//.........这里部分代码省略.........
     //$1 'Zend/Search/Lucene.php';
     $maxTerms = Zend_Search_Lucene::getTermsPerQueryLimit();
     foreach ($fields as $field) {
         $index->resetTermsStream();
         //$1 'Zend/Search/Lucene/Index/Term.php';
         if ($prefix != '') {
             $index->skipTo(new Zend_Search_Lucene_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) {
                         //$1 'Zend/Search/Lucene/Exception.php';
                         throw new Zend_Search_Lucene_Exception('Terms per query limit is reached.');
                     }
                 }
                 $index->nextTerm();
             }
         } else {
             $index->skipTo(new Zend_Search_Lucene_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) {
                         //$1 'Zend/Search/Lucene/Exception.php';
                         throw new Zend_Search_Lucene_Exception('Terms per query limit is reached.');
                     }
                 }
                 $index->nextTerm();
             }
         }
         $index->closeTermsStream();
     }
     if (count($this->_matches) == 0) {
         //$1 'Zend/Search/Lucene/Search/Query/Empty.php';
         return new Zend_Search_Lucene_Search_Query_Empty();
     } else {
         if (count($this->_matches) == 1) {
             //$1 'Zend/Search/Lucene/Search/Query/Term.php';
             return new Zend_Search_Lucene_Search_Query_Term(reset($this->_matches));
         } else {
             //$1 'Zend/Search/Lucene/Search/Query/Boolean.php';
             $rewrittenQuery = new Zend_Search_Lucene_Search_Query_Boolean();
             array_multisort($this->_scores, SORT_DESC, SORT_NUMERIC, $this->_termKeys, SORT_ASC, SORT_STRING, $this->_matches);
             $termCount = 0;
             //$1 'Zend/Search/Lucene/Search/Query/Term.php';
             foreach ($this->_matches as $id => $matchedTerm) {
                 $subquery = new Zend_Search_Lucene_Search_Query_Term($matchedTerm);
                 $subquery->setBoost($this->_scores[$id]);
                 $rewrittenQuery->addSubquery($subquery);
                 $termCount++;
                 if ($termCount >= self::MAX_CLAUSE_COUNT) {
                     break;
                 }
             }
             return $rewrittenQuery;
         }
     }
 }

 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param Zend_Search_Lucene_Interface $index
  * @return Zend_Search_Lucene_Search_Query
  */
 public function rewrite(Zend_Search_Lucene_Interface $index)
 {
     if (count($this->_terms) == 0) {
         require_once 'Zend/Search/Lucene/Search/Query/Empty.php';
         return new Zend_Search_Lucene_Search_Query_Empty();
     }
     // Check, that all fields are qualified
     $allQualified = true;
     foreach ($this->_terms as $term) {
         if ($term->field === null) {
             $allQualified = false;
             break;
         }
     }
     if ($allQualified) {
         return $this;
     } else {
         /** transform multiterm query to boolean and apply rewrite() method to subqueries. */
         require_once 'Zend/Search/Lucene/Search/Query/Boolean.php';
         $query = new Zend_Search_Lucene_Search_Query_Boolean();
         $query->setBoost($this->getBoost());
         require_once 'Zend/Search/Lucene/Search/Query/Term.php';
         foreach ($this->_terms as $termId => $term) {
             $subquery = new Zend_Search_Lucene_Search_Query_Term($term);
             $query->addSubquery($subquery->rewrite($index), $this->_signs === null ? true : $this->_signs[$termId]);
         }
         return $query;
     }
 }

 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param Zend_Search_Lucene_Interface $index
  * @return Zend_Search_Lucene_Search_Query
  */
 public function rewrite(Zend_Search_Lucene_Interface $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) {
         require_once 'Zend/Search/Lucene/Search/Query/Boolean.php';
         $query = new Zend_Search_Lucene_Search_Query_Boolean();
         $query->setBoost($this->getBoost());
         require_once 'Zend/Search/Lucene.php';
         if (Zend_Search_Lucene::getDefaultSearchField() === null) {
             $searchFields = $index->getFieldNames(true);
         } else {
             $searchFields = array(Zend_Search_Lucene::getDefaultSearchField());
         }
         foreach ($searchFields as $fieldName) {
             $subquery = new Zend_Search_Lucene_Search_Query_Preprocessing_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
     require_once 'Zend/Search/Lucene/Index/Term.php';
     $term = new Zend_Search_Lucene_Index_Term($this->_phrase, $this->_field);
     if ($index->hasTerm($term)) {
         require_once 'Zend/Search/Lucene/Search/Query/Term.php';
         $query = new Zend_Search_Lucene_Search_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
     require_once 'Zend/Search/Lucene/Analysis/Analyzer.php';
     $tokens = Zend_Search_Lucene_Analysis_Analyzer::getDefault()->tokenize($this->_phrase, $this->_phraseEncoding);
     if (count($tokens) == 0) {
         $this->_matches = array();
         require_once 'Zend/Search/Lucene/Search/Query/Insignificant.php';
         return new Zend_Search_Lucene_Search_Query_Insignificant();
     }
     if (count($tokens) == 1) {
         require_once 'Zend/Search/Lucene/Index/Term.php';
         $term = new Zend_Search_Lucene_Index_Term($tokens[0]->getTermText(), $this->_field);
         require_once 'Zend/Search/Lucene/Search/Query/Term.php';
         $query = new Zend_Search_Lucene_Search_Query_Term($term);
         $query->setBoost($this->getBoost());
         $this->_matches = $query->getQueryTerms();
         return $query;
     }
     //It's non-trivial phrase query
     $position = -1;
     require_once 'Zend/Search/Lucene/Search/Query/Phrase.php';
     $query = new Zend_Search_Lucene_Search_Query_Phrase();
     require_once 'Zend/Search/Lucene/Index/Term.php';
     foreach ($tokens as $token) {
         $position += $token->getPositionIncrement();
         $term = new Zend_Search_Lucene_Index_Term($token->getTermText(), $this->_field);
         $query->addTerm($term, $position);
         $query->setSlop($this->getSlop());
     }
     $this->_matches = $query->getQueryTerms();
     return $query;
 }

 /**
  * Optimize query in the context of specified index
  *
  * @param Zend_Search_Lucene_Interface $index
  * @return Zend_Search_Lucene_Search_Query
  */
 public function optimize(Zend_Search_Lucene_Interface $index)
 {
     $subqueries = array();
     $signs = array();
     // Optimize all subqueries
     foreach ($this->_subqueries as $id => $subquery) {
         $subqueries[] = $subquery->optimize($index);
         $signs[] = $this->_signs === null ? true : $this->_signs[$id];
     }
     // Remove insignificant subqueries
     foreach ($subqueries as $id => $subquery) {
         if ($subquery instanceof Zend_Search_Lucene_Search_Query_Insignificant) {
             // Insignificant subquery has to be removed anyway
             unset($subqueries[$id]);
             unset($signs[$id]);
         }
     }
     if (count($subqueries) == 0) {
         // Boolean query doesn't has non-insignificant subqueries
         return new Zend_Search_Lucene_Search_Query_Insignificant();
     }
     // Check if all non-insignificant subqueries are prohibited
     $allProhibited = true;
     foreach ($signs as $sign) {
         if ($sign !== false) {
             $allProhibited = false;
             break;
         }
     }
     if ($allProhibited) {
         return new Zend_Search_Lucene_Search_Query_Insignificant();
     }
     // Check for empty subqueries
     foreach ($subqueries as $id => $subquery) {
         if ($subquery instanceof Zend_Search_Lucene_Search_Query_Empty) {
             if ($signs[$id] === true) {
                 // Matching is required, but is actually empty
                 return new Zend_Search_Lucene_Search_Query_Empty();
             } else {
                 // Matching is optional or prohibited, but is empty
                 // Remove it from subqueries and signs list
                 unset($subqueries[$id]);
                 unset($signs[$id]);
             }
         }
     }
     // Check, if reduced subqueries list is empty
     if (count($subqueries) == 0) {
         return new Zend_Search_Lucene_Search_Query_Empty();
     }
     // Check if all non-empty subqueries are prohibited
     $allProhibited = true;
     foreach ($signs as $sign) {
         if ($sign !== false) {
             $allProhibited = false;
             break;
         }
     }
     if ($allProhibited) {
         return new Zend_Search_Lucene_Search_Query_Empty();
     }
     // Check, if reduced subqueries list has only one entry
     if (count($subqueries) == 1) {
         // It's a query with only one required or optional clause
         // (it's already checked, that it's not a prohibited clause)
         if ($this->getBoost() == 1) {
             return reset($subqueries);
         }
         $optimizedQuery = clone reset($subqueries);
         $optimizedQuery->setBoost($optimizedQuery->getBoost() * $this->getBoost());
         return $optimizedQuery;
     }
     // Prepare first candidate for optimized query
     $optimizedQuery = new Zend_Search_Lucene_Search_Query_Boolean($subqueries, $signs);
     $optimizedQuery->setBoost($this->getBoost());
     $terms = array();
     $tsigns = array();
     $boostFactors = array();
     // Try to decompose term and multi-term subqueries
     foreach ($subqueries as $id => $subquery) {
         if ($subquery instanceof Zend_Search_Lucene_Search_Query_Term) {
             $terms[] = $subquery->getTerm();
             $tsigns[] = $signs[$id];
             $boostFactors[] = $subquery->getBoost();
             // remove subquery from a subqueries list
             unset($subqueries[$id]);
             unset($signs[$id]);
         } else {
             if ($subquery instanceof Zend_Search_Lucene_Search_Query_MultiTerm) {
                 $subTerms = $subquery->getTerms();
                 $subSigns = $subquery->getSigns();
                 if ($signs[$id] === true) {
                     // It's a required multi-term subquery.
                     // Something like '... +(+term1 -term2 term3 ...) ...'
//.........这里部分代码省略.........

 /**
  * Display search results.
  */
 function searchResults()
 {
     ZendSearchHandler::setupTemplate();
     $plugin =& PluginRegistry::getPlugin('generic', 'ZendSearchPlugin');
     $isUsingSolr = $plugin->isUsingSolr();
     if ($isUsingSolr) {
         $ch = curl_init();
         curl_setopt($ch, CURLOPT_URL, $plugin->getSetting('solrUrl') . '/select');
         curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
         curl_setopt($ch, CURLOPT_TIMEOUT, 10);
         curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
         curl_setopt($ch, CURLOPT_ENCODING, '');
         curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
         curl_setopt($ch, CURLOPT_DNS_USE_GLOBAL_CACHE, 0);
         curl_setopt($ch, CURLOPT_POST, 1);
         $query = '';
     } else {
         $index =& $plugin->getIndex();
         $query = new Zend_Search_Lucene_Search_Query_Boolean();
     }
     $q = Request::getUserVar('q');
     if (!empty($q)) {
         if ($isUsingSolr) {
             $query .= 'text:"' . ZendSearchHandler::luceneEscape($q) . '" ';
         } else {
             $query->addSubquery(Zend_Search_Lucene_Search_QueryParser::parse($q));
         }
     }
     $searchFormElementDao =& DAORegistry::getDAO('SearchFormElementDAO');
     $searchFormElements =& $searchFormElementDao->getSearchFormElements();
     while ($searchFormElement =& $searchFormElements->next()) {
         $searchFormElementId = $searchFormElement->getSearchFormElementId();
         $symbolic = $searchFormElement->getSymbolic();
         switch ($searchFormElement->getType()) {
             case SEARCH_FORM_ELEMENT_TYPE_SELECT:
             case SEARCH_FORM_ELEMENT_TYPE_STRING:
                 $term = Request::getUserVar($symbolic);
                 if (!empty($term)) {
                     if ($isUsingSolr) {
                         $query .= $symbolic . ':"' . ZendSearchHandler::luceneEscape($term) . '" ';
                     } else {
                         $query->addSubquery(new Zend_Search_Lucene_Search_Query_Term(new Zend_Search_Lucene_Index_Term($term, $symbolic)), true);
                     }
                 }
                 break;
             case SEARCH_FORM_ELEMENT_TYPE_DATE:
                 $from = Request::getUserDateVar($symbolic . '-from');
                 $to = Request::getUserDateVar($symbolic . '-to');
                 if (!empty($from) && !empty($to)) {
                     if ($isUsingSolr) {
                         $query .= $symbolic . ':[' . strftime('%Y-%m-%dT%H:%M:%SZ', $from) . ' TO ' . strftime('%Y-%m-%dT%H:%M:%SZ', $to) . '] ';
                     } else {
                         $fromTerm = new Zend_Search_Lucene_Index_Term($from, $symbolic);
                         $toTerm = new Zend_Search_Lucene_Index_Term($to, $symbolic);
                         $query->addSubquery(new Zend_Search_Lucene_Search_Query_Range($fromTerm, $toTerm, true), true);
                     }
                 }
                 break;
             default:
                 fatalError('Unknown element type!');
         }
         unset($searchFormElement);
     }
     $rangeInfo =& PKPHandler::getRangeInfo('results');
     if ($isUsingSolr) {
         $itemsPerPage = Config::getVar('interface', 'items_per_page');
         curl_setopt($ch,