PHP Zend_Search_Lucene_Search_QueryParser類代碼示例

 public function search($keywords, $charset = 'utf-8')
 {
     $index = new Zend_Search_Lucene(ZY_ROOT . '/index');
     $query = Zend_Search_Lucene_Search_QueryParser::parse($keywords, $charset);
     $hits = $index->find($query);
     return $hits;
 }

 public static function searchLuceneWithValues(Doctrine_Table $table, $luceneQueryString, $culture = null)
 {
     // Ugh: UTF8 Lucene is case sensitive work around this
     if (function_exists('mb_strtolower')) {
         $luceneQueryString = mb_strtolower($luceneQueryString);
     } else {
         $luceneQueryString = strtolower($luceneQueryString);
     }
     // We have to register the autoloader before we can use these classes
     self::registerZend();
     $luceneQuery = Zend_Search_Lucene_Search_QueryParser::parse($luceneQueryString);
     $query = new Zend_Search_Lucene_Search_Query_Boolean();
     $query->addSubquery($luceneQuery, true);
     if (!is_null($culture)) {
         $culture = self::normalizeCulture($culture);
         $cultureTerm = new Zend_Search_Lucene_Index_Term($culture, 'culture');
         // Oops, this said $aTerm before. Thanks to Quentin Dugauthier
         $cultureQuery = new Zend_Search_Lucene_Search_Query_Term($cultureTerm);
         $query->addSubquery($cultureQuery, true);
     }
     $index = $table->getLuceneIndex();
     $hits = $index->find($query);
     $ids = array();
     foreach ($hits as $hit) {
         $ids[$hit->primarykey] = $hit;
     }
     return $ids;
 }

 /**
  * Creates a new ZendLucene handler connection
  *
  * @param string $location
  */
 public function __construct($location)
 {
     /**
      * We're using realpath here because Zend_Search_Lucene does not do
      * that itself. It can cause issues because their destructor uses the
      * same filename but the cwd could have been changed.
      */
     $location = realpath($location);
     /* If the $location doesn't exist, ZSL throws a *generic* exception. We
      * don't care here though and just always assume it is because the
      * index does not exist. If it doesn't exist, we create it.
      */
     try {
         $this->connection = Zend_Search_Lucene::open($location);
     } catch (Zend_Search_Lucene_Exception $e) {
         $this->connection = Zend_Search_Lucene::create($location);
     }
     $this->inTransaction = 0;
     if (!$this->connection) {
         throw new ezcSearchCanNotConnectException('zendlucene', $location);
     }
     // Set proper default encoding for query parser
     Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding('UTF-8');
     Zend_Search_Lucene_Analysis_Analyzer::setDefault(new Zend_Search_Lucene_Analysis_Analyzer_Common_Utf8Num_CaseInsensitive());
 }

 /**
  * Method to perform a search. This function returns results from Zend_Lucene_Search
  * and is unpolished as it doesn't check permission issues, etc.
  * 
  * @access private
  * @param string $text Text to search for
  * @param string $module Module to search items for
  * @param string $context Context in which to search
  * @param array $extra Any additional items
  * @return object
  */
 private function search($text, $module = NULL, $context = NULL, $extra = array())
 {
     $objIndexData = $this->getObject('indexdata');
     $indexer = $objIndexData->checkIndexPath();
     // Some cllean up till we can find a better way
     $phrase = trim(str_replace(':', ' ', $text));
     $phrase = trim(str_replace('+', ' ', $phrase));
     $phrase = trim(str_replace('-', ' ', $phrase));
     if ($module != NULL) {
         if ($text != '') {
             $phrase .= ' AND ';
         }
         $phrase .= ' module:' . $module . ' ';
     }
     if ($context != NULL) {
         if ($phrase != '') {
             $phrase .= ' AND ';
         }
         $phrase .= ' context:' . $context . ' ';
     }
     if (is_array($extra) && count($extra) > 0) {
         foreach ($extra as $item => $value) {
             if ($phrase != '') {
                 $phrase .= ' AND ';
             }
             $phrase .= $item . ':' . $value . ' ';
         }
     }
     //echo $phrase;
     $query = Zend_Search_Lucene_Search_QueryParser::parse($phrase);
     return $indexer->find($query);
 }

    /**
     * Parses a query string
     *
     * @param string $strQuery
     * @param string $encoding
     * @return Zend_Search_Lucene_Search_Query
     * @throws Zend_Search_Lucene_Search_QueryParserException
     */
    public static function parse($strQuery, $encoding = null)
    {
        self::_getInstance();

        // Reset FSM if previous parse operation didn't return it into a correct state
        self::$_instance->reset();

        require_once 'Zend/Search/Lucene/Search/QueryParserException.php';
        try {
            self::$_instance->_encoding     = ($encoding !== null) ? $encoding : self::$_instance->_defaultEncoding;
            self::$_instance->_lastToken    = null;
            self::$_instance->_context      = new Zend_Search_Lucene_Search_QueryParserContext(self::$_instance->_encoding);
            self::$_instance->_contextStack = array();
            self::$_instance->_tokens       = self::$_instance->_lexer->tokenize($strQuery, self::$_instance->_encoding);

            // Empty query
            if (count(self::$_instance->_tokens) == 0) {
                return new Zend_Search_Lucene_Search_Query_Insignificant();
            }


            foreach (self::$_instance->_tokens as $token) {
                try {
                    self::$_instance->_currentToken = $token;
                    self::$_instance->process($token->type);

                    self::$_instance->_lastToken = $token;
                } catch (Exception $e) {
                    if (strpos($e->getMessage(), 'There is no any rule for') !== false) {
                        throw new Zend_Search_Lucene_Search_QueryParserException( 'Syntax error at char position ' . $token->position . '.' );
                    }

                    throw $e;
                }
            }

            if (count(self::$_instance->_contextStack) != 0) {
                throw new Zend_Search_Lucene_Search_QueryParserException('Syntax Error: mismatched parentheses, every opening must have closing.' );
            }

            return self::$_instance->_context->getQuery();
        } catch (Zend_Search_Lucene_Search_QueryParserException $e) {
            if (self::$_instance->_suppressQueryParsingExceptions) {
                $queryTokens = Zend_Search_Lucene_Analysis_Analyzer::getDefault()->tokenize($strQuery, self::$_instance->_encoding);

                $query = new Zend_Search_Lucene_Search_Query_MultiTerm();
                $termsSign = (self::$_instance->_defaultOperator == self::B_AND) ? true /* required term */ :
                                                                                   null /* optional term */;

                foreach ($queryTokens as $token) {
                    $query->addTerm(new Zend_Search_Lucene_Index_Term($token->getTermText()), $termsSign);
                }


                return $query;
            } else {
                throw $e;
            }
        }
    }

 public function __construct()
 {
     Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding('utf-8');
     //set default encoding
     Zend_Search_Lucene_Analysis_Analyzer::setDefault(new Zend_Search_Lucene_Analysis_Analyzer_CJK());
     //set default Analyzer
 }

 /**
  * Parses a query string
  *
  * @param string $strQuery
  * @param string $encoding
  * @return Zend_Search_Lucene_Search_Query
  * @throws Zend_Search_Lucene_Search_QueryParserException
  */
 public static function parse($strQuery, $encoding = null)
 {
     if (self::$_instance === null) {
         self::$_instance = new Zend_Search_Lucene_Search_QueryParser();
     }
     self::$_instance->_encoding = $encoding !== null ? $encoding : self::$_instance->_defaultEncoding;
     self::$_instance->_lastToken = null;
     self::$_instance->_context = new Zend_Search_Lucene_Search_QueryParserContext(self::$_instance->_encoding);
     self::$_instance->_contextStack = array();
     self::$_instance->_tokens = self::$_instance->_lexer->tokenize($strQuery, self::$_instance->_encoding);
     // Empty query
     if (count(self::$_instance->_tokens) == 0) {
         return new Zend_Search_Lucene_Search_Query_Empty();
     }
     foreach (self::$_instance->_tokens as $token) {
         try {
             self::$_instance->_currentToken = $token;
             self::$_instance->process($token->type);
             self::$_instance->_lastToken = $token;
         } catch (Exception $e) {
             if (strpos($e->getMessage(), 'There is no any rule for') !== false) {
                 throw new Zend_Search_Lucene_Search_QueryParserException('Syntax error at char position ' . $token->position . '.');
             }
             throw $e;
         }
     }
     if (count(self::$_instance->_contextStack) != 0) {
         throw new Zend_Search_Lucene_Search_QueryParserException('Syntax Error: mismatched parentheses, every opening must have closing.');
     }
     return self::$_instance->_context->getQuery();
 }

 protected function useSearchIndex($slug)
 {
     if (!dmConfig::get('smart_404')) {
         return false;
     }
     try {
         $searchIndex = $this->serviceContainer->get('search_engine')->getCurrentIndex();
         $queryString = str_replace('/', ' ', dmString::unSlugify($slug));
         $query = Zend_Search_Lucene_Search_QueryParser::parse($queryString);
         $results = $searchIndex->search($query);
         $foundPage = null;
         foreach ($results as $result) {
             if ($result->getScore() > 0.5) {
                 if ($foundPage = $result->getPage()) {
                     break;
                 }
             } else {
                 break;
             }
         }
         if ($foundPage) {
             return $this->serviceContainer->getService('helper')->link($foundPage)->getHref();
         }
     } catch (Exception $e) {
         $this->dispatcher->notify(new sfEvent($this, 'application.log', array('Can not use search index to find redirection for slug ' . $slug, sfLogger::ERR)));
         if (sfConfig::get('dm_debug')) {
             throw $e;
         }
     }
 }

 public function index($msg = NULL)
 {
     $results = NULL;
     $results2 = NULL;
     $query = NULL;
     $view = new View('search_example');
     $view->bind("results", $results)->bind("results2", $results2)->bind("query", $query)->bind("msg", $msg);
     if (!empty($_GET["q"])) {
         try {
             $query = $_GET["q"];
             $form = $_GET["form"];
             if ($form == "artists") {
                 $results = Search::instance()->find($query);
             } else {
                 Search::instance()->load_search_libs();
                 $query = Zend_Search_Lucene_Search_QueryParser::parse($query);
                 $hits = Search::instance()->find($query);
                 if (sizeof($hits) > 0) {
                     $results2 = $query->highlightMatches(iconv('UTF-8', 'ASCII//TRANSLIT', $hits[0]->body));
                 } else {
                     $results2 = '<p style="color:#f00">No results found</p>';
                 }
             }
         } catch (Exception $e) {
             Kohana::log("error", $e);
         }
     }
     $view->render(TRUE);
 }

 /**
  * Adds a string that is parsed into Zend API queries
  * @param string $query The query to parse
  * @param string $encoding The encoding to parse query as
  * 
  * @return sfLuceneCriteria
  */
 public function addString($query, $encoding = null, $type = true)
 {
     $this->search->configure();
     // setup query parser
     $this->add(Zend_Search_Lucene_Search_QueryParser::parse($query, $encoding), $type);
     return $this;
 }

 public function actionIndex()
 {
     $this->webpageType = 'SearchResultsPage';
     $type = '';
     if (isset($_GET['type'])) {
         $type = $_GET['type'];
     }
     if (isset($_GET['q'])) {
         //            $originalQuery = $_GET['q'];
         $queryString = $originalQuery = isset($_GET['q']) ? $_GET['q'] : '';
         $index = new Zend_Search_Lucene($this->_indexFile);
         //only look for queryString in title and content, well if advanced search techniques aren't used
         if (!(strpos(strtolower($queryString), 'and') || strpos(strtolower($queryString), 'or') || strpos(strtolower($queryString), ':'))) {
             $queryString = "title:{$queryString} OR content:{$queryString}";
         }
         if ($type) {
             $queryString .= ' AND type:' . $type;
         }
         $results = $index->find($queryString);
         $query = Zend_Search_Lucene_Search_QueryParser::parse($queryString);
         $this->render('index', compact('results', 'originalQuery', 'query', 'type'));
     } else {
         $this->render('advanced', array('type' => $type));
     }
 }

 /**
  * Returns Zend_Search_Lucene instance for given subroot
  *
  * every subroot has it's own instance
  *
  * @param Kwf_Component_Data for this index
  * @return Zend_Search_Lucene_Interface
  */
 public static function getInstance(Kwf_Component_Data $subroot)
 {
     while ($subroot) {
         if (Kwc_Abstract::getFlag($subroot->componentClass, 'subroot')) {
             break;
         }
         $subroot = $subroot->parent;
     }
     if (!$subroot) {
         $subroot = Kwf_Component_Data_Root::getInstance();
     }
     static $instance = array();
     if (!isset($instance[$subroot->componentId])) {
         $analyzer = new Zend_Search_Lucene_Analysis_Analyzer_Common_Utf8Num_CaseInsensitive();
         $analyzer->addFilter(new Zend_Search_Lucene_Analysis_TokenFilter_ShortWords(2));
         //$stopWords = explode(' ', 'der dir das einer eine ein und oder doch ist sind an in vor nicht wir ihr sie es ich');
         //$analyzer->addFilter(new Zend_Search_Lucene_Analysis_TokenFilter_StopWords($stopWords));
         Zend_Search_Lucene_Analysis_Analyzer::setDefault($analyzer);
         Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding('utf-8');
         Zend_Search_Lucene_Storage_Directory_Filesystem::setDefaultFilePermissions(0666);
         $path = 'cache/fulltext';
         $path .= '/' . $subroot->componentId;
         try {
             $instance[$subroot->componentId] = Zend_Search_Lucene::open($path);
         } catch (Zend_Search_Lucene_Exception $e) {
             $instance[$subroot->componentId] = Zend_Search_Lucene::create($path);
         }
     }
     return $instance[$subroot->componentId];
 }

 /**
  * Process and render search results. Uses the Lucene_results.ss template to
  * render the form.
  * 
  * @access public
  * @param   array           $data       The raw request data submitted by user
  * @param   Form            $form       The form instance that was submitted
  * @param   SS_HTTPRequest  $request    Request generated for this action
  * @return  String                      The rendered form, for inclusion into the page template.
  */
 public function ZendSearchLuceneResults($data, $form, $request)
 {
     $querystring = $form->Fields()->dataFieldByName('Search')->dataValue();
     $query = Zend_Search_Lucene_Search_QueryParser::parse($querystring);
     $hits = ZendSearchLuceneWrapper::find($query);
     $data = $this->getDataArrayFromHits($hits, $request);
     return $this->owner->customise($data)->renderWith(array('Lucene_results', 'Page'));
 }

 public function searchTag($tag, $value)
 {
     if (!$this->_enabled) {
         return array();
     }
     Zend_Search_Lucene::setDefaultSearchField($tag);
     $query = Zend_Search_Lucene_Search_QueryParser::parse($value);
     return $this->_index->find($query);
 }

 private function search($terms)
 {
     Yii::import('application.vendor.*');
     require_once 'Zend/Search/Lucene.php';
     $index = new Zend_Search_Lucene(Yii::getPathOfAlias('application.index'));
     $result = $index->find($terms);
     $query = Zend_Search_Lucene_Search_QueryParser::parse($terms);
     return $result;
 }