tweet_live: comparison web/Zend/Search/Lucene.php

equal deleted inserted replaced

--1:000000000000
+:4eba9c11703f
+<?php
+/**
+* Zend Framework
+*
+* LICENSE
+*
+* This source file is subject to the new BSD license that is bundled
+* with this package in the file LICENSE.txt.
+* It is also available through the world-wide-web at this URL:
+* http://framework.zend.com/license/new-bsd
+* If you did not receive a copy of the license and are unable to
+* obtain it through the world-wide-web, please send an email
+* to license@zend.com so we can send you a copy immediately.
+*
+* @category   Zend
+* @package    Zend_Search_Lucene
+* @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+* @license    http://framework.zend.com/license/new-bsd     New BSD License
+* @version    $Id: Lucene.php 22987 2010-09-21 10:39:53Z alexander $
+*/
+/** User land classes and interfaces turned on by Zend/Search/Lucene.php file inclusion. */
+/** @todo Section should be removed with ZF 2.0 release as obsolete                      */
+/** Zend_Search_Lucene_Document_Html */
+require_once 'Zend/Search/Lucene/Document/Html.php';
+/** Zend_Search_Lucene_Document_Docx */
+require_once 'Zend/Search/Lucene/Document/Docx.php';
+/** Zend_Search_Lucene_Document_Pptx */
+require_once 'Zend/Search/Lucene/Document/Pptx.php';
+/** Zend_Search_Lucene_Document_Xlsx */
+require_once 'Zend/Search/Lucene/Document/Xlsx.php';
+/** Zend_Search_Lucene_Search_QueryParser */
+require_once 'Zend/Search/Lucene/Search/QueryParser.php';
+/** Zend_Search_Lucene_Search_QueryHit */
+require_once 'Zend/Search/Lucene/Search/QueryHit.php';
+/** Zend_Search_Lucene_Analysis_Analyzer */
+require_once 'Zend/Search/Lucene/Analysis/Analyzer.php';
+/** Zend_Search_Lucene_Search_Query_Term */
+require_once 'Zend/Search/Lucene/Search/Query/Term.php';
+/** Zend_Search_Lucene_Search_Query_Phrase */
+require_once 'Zend/Search/Lucene/Search/Query/Phrase.php';
+/** Zend_Search_Lucene_Search_Query_MultiTerm */
+require_once 'Zend/Search/Lucene/Search/Query/MultiTerm.php';
+/** Zend_Search_Lucene_Search_Query_Wildcard */
+require_once 'Zend/Search/Lucene/Search/Query/Wildcard.php';
+/** Zend_Search_Lucene_Search_Query_Range */
+require_once 'Zend/Search/Lucene/Search/Query/Range.php';
+/** Zend_Search_Lucene_Search_Query_Fuzzy */
+require_once 'Zend/Search/Lucene/Search/Query/Fuzzy.php';
+/** Zend_Search_Lucene_Search_Query_Boolean */
+require_once 'Zend/Search/Lucene/Search/Query/Boolean.php';
+/** Zend_Search_Lucene_Search_Query_Empty */
+require_once 'Zend/Search/Lucene/Search/Query/Empty.php';
+/** Zend_Search_Lucene_Search_Query_Insignificant */
+require_once 'Zend/Search/Lucene/Search/Query/Insignificant.php';
+/** Internally used classes */
+/** Zend_Search_Lucene_Interface */
+require_once 'Zend/Search/Lucene/Interface.php';
+/** Zend_Search_Lucene_Index_SegmentInfo */
+require_once 'Zend/Search/Lucene/Index/SegmentInfo.php';
+/** Zend_Search_Lucene_LockManager */
+require_once 'Zend/Search/Lucene/LockManager.php';
+/**
+* @category   Zend
+* @package    Zend_Search_Lucene
+* @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+* @license    http://framework.zend.com/license/new-bsd     New BSD License
+*/
+class Zend_Search_Lucene implements Zend_Search_Lucene_Interface
+{
+/**
+* Default field name for search
+*
+* Null means search through all fields
+*
+* @var string
+*/
+private static $_defaultSearchField = null;
+/**
+* Result set limit
+*
+* 0 means no limit
+*
+* @var integer
+*/
+private static $_resultSetLimit = 0;
+/**
+* Terms per query limit
+*
+* 0 means no limit
+*
+* @var integer
+*/
+private static $_termsPerQueryLimit = 1024;
+/**
+* File system adapter.
+*
+* @var Zend_Search_Lucene_Storage_Directory
+*/
+private $_directory = null;
+/**
+* File system adapter closing option
+*
+* @var boolean
+*/
+private $_closeDirOnExit = true;
+/**
+* Writer for this index, not instantiated unless required.
+*
+* @var Zend_Search_Lucene_Index_Writer
+*/
+private $_writer = null;
+/**
+* Array of Zend_Search_Lucene_Index_SegmentInfo objects for current version of index.
+*
+* @var array Zend_Search_Lucene_Index_SegmentInfo
+*/
+private $_segmentInfos = array();
+/**
+* Number of documents in this index.
+*
+* @var integer
+*/
+private $_docCount = 0;
+/**
+* Flag for index changes
+*
+* @var boolean
+*/
+private $_hasChanges = false;
+/**
+* Signal, that index is already closed, changes are fixed and resources are cleaned up
+*
+* @var boolean
+*/
+private $_closed = false;
+/**
+* Number of references to the index object
+*
+* @var integer
+*/
+private $_refCount = 0;
+/**
+* Current segment generation
+*
+* @var integer
+*/
+private $_generation;
+const FORMAT_PRE_2_1 = 0;
+const FORMAT_2_1     = 1;
+const FORMAT_2_3     = 2;
+/**
+* Index format version
+*
+* @var integer
+*/
+private $_formatVersion;
+/**
+* Create index
+*
+* @param mixed $directory
+* @return Zend_Search_Lucene_Interface
+*/
+public static function create($directory)
+{
+/** Zend_Search_Lucene_Proxy */
+require_once 'Zend/Search/Lucene/Proxy.php';
+return new Zend_Search_Lucene_Proxy(new Zend_Search_Lucene($directory, true));
+}
+/**
+* Open index
+*
+* @param mixed $directory
+* @return Zend_Search_Lucene_Interface
+*/
+public static function open($directory)
+{
+/** Zend_Search_Lucene_Proxy */
+require_once 'Zend/Search/Lucene/Proxy.php';
+return new Zend_Search_Lucene_Proxy(new Zend_Search_Lucene($directory, false));
+}
+/** Generation retrieving counter */
+const GENERATION_RETRIEVE_COUNT = 10;
+/** Pause between generation retrieving attempts in milliseconds */
+const GENERATION_RETRIEVE_PAUSE = 50;
+/**
+* Get current generation number
+*
+* Returns generation number
+* 0 means pre-2.1 index format
+* -1 means there are no segments files.
+*
+* @param Zend_Search_Lucene_Storage_Directory $directory
+* @return integer
+* @throws Zend_Search_Lucene_Exception
+*/
+public static function getActualGeneration(Zend_Search_Lucene_Storage_Directory $directory)
+{
+/**
+* Zend_Search_Lucene uses segments.gen file to retrieve current generation number
+*
+* Apache Lucene index format documentation mentions this method only as a fallback method
+*
+* Nevertheless we use it according to the performance considerations
+*
+* @todo check if we can use some modification of Apache Lucene generation determination algorithm
+*       without performance problems
+*/
+require_once 'Zend/Search/Lucene/Exception.php';
+try {
+for ($count = 0; $count < self::GENERATION_RETRIEVE_COUNT; $count++) {
+// Try to get generation file
+$genFile = $directory->getFileObject('segments.gen', false);
+$format = $genFile->readInt();
+if ($format != (int)0xFFFFFFFE) {
+throw new Zend_Search_Lucene_Exception('Wrong segments.gen file format');
+}
+$gen1 = $genFile->readLong();
+$gen2 = $genFile->readLong();
+if ($gen1 == $gen2) {
+return $gen1;
+}
+usleep(self::GENERATION_RETRIEVE_PAUSE * 1000);
+}
+// All passes are failed
+throw new Zend_Search_Lucene_Exception('Index is under processing now');
+} catch (Zend_Search_Lucene_Exception $e) {
+if (strpos($e->getMessage(), 'is not readable') !== false) {
+try {
+// Try to open old style segments file
+$segmentsFile = $directory->getFileObject('segments', false);
+// It's pre-2.1 index
+return 0;
+} catch (Zend_Search_Lucene_Exception $e) {
+if (strpos($e->getMessage(), 'is not readable') !== false) {
+return -1;
+} else {
+throw new Zend_Search_Lucene_Exception($e->getMessage(), $e->getCode(), $e);
+}
+}
+} else {
+throw new Zend_Search_Lucene_Exception($e->getMessage(), $e->getCode(), $e);
+}
+}
+return -1;
+}
+/**
+* Get generation number associated with this index instance
+*
+* The same generation number in pair with document number or query string
+* guarantees to give the same result while index retrieving.
+* So it may be used for search result caching.
+*
+* @return integer
+*/
+public function getGeneration()
+{
+return $this->_generation;
+}
+/**
+* Get segments file name
+*
+* @param integer $generation
+* @return string
+*/
+public static function getSegmentFileName($generation)
+{
+if ($generation == 0) {
+return 'segments';
+}
+return 'segments_' . base_convert($generation, 10, 36);
+}
+/**
+* Get index format version
+*
+* @return integer
+*/
+public function getFormatVersion()
+{
+return $this->_formatVersion;
+}
+/**
+* Set index format version.
+* Index is converted to this format at the nearest upfdate time
+*
+* @param int $formatVersion
+* @throws Zend_Search_Lucene_Exception
+*/
+public function setFormatVersion($formatVersion)
+{
+if ($formatVersion != self::FORMAT_PRE_2_1  &&
+$formatVersion != self::FORMAT_2_1  &&
+$formatVersion != self::FORMAT_2_3) {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Unsupported index format');
+}
+$this->_formatVersion = $formatVersion;
+}
+/**
+* Read segments file for pre-2.1 Lucene index format
+*
+* @throws Zend_Search_Lucene_Exception
+*/
+private function _readPre21SegmentsFile()
+{
+$segmentsFile = $this->_directory->getFileObject('segments');
+$format = $segmentsFile->readInt();
+if ($format != (int)0xFFFFFFFF) {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Wrong segments file format');
+}
+// read version
+$segmentsFile->readLong();
+// read segment name counter
+$segmentsFile->readInt();
+$segments = $segmentsFile->readInt();
+$this->_docCount = 0;
+// read segmentInfos
+for ($count = 0; $count < $segments; $count++) {
+$segName = $segmentsFile->readString();
+$segSize = $segmentsFile->readInt();
+$this->_docCount += $segSize;
+$this->_segmentInfos[$segName] =
+new Zend_Search_Lucene_Index_SegmentInfo($this->_directory,
+$segName,
+$segSize);
+}
+// Use 2.1 as a target version. Index will be reorganized at update time.
+$this->_formatVersion = self::FORMAT_2_1;
+}
+/**
+* Read segments file
+*
+* @throws Zend_Search_Lucene_Exception
+*/
+private function _readSegmentsFile()
+{
+$segmentsFile = $this->_directory->getFileObject(self::getSegmentFileName($this->_generation));
+$format = $segmentsFile->readInt();
+if ($format == (int)0xFFFFFFFC) {
+$this->_formatVersion = self::FORMAT_2_3;
+} else if ($format == (int)0xFFFFFFFD) {
+$this->_formatVersion = self::FORMAT_2_1;
+} else {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Unsupported segments file format');
+}
+// read version
+$segmentsFile->readLong();
+// read segment name counter
+$segmentsFile->readInt();
+$segments = $segmentsFile->readInt();
+$this->_docCount = 0;
+// read segmentInfos
+for ($count = 0; $count < $segments; $count++) {
+$segName = $segmentsFile->readString();
+$segSize = $segmentsFile->readInt();
+// 2.1+ specific properties
+$delGen = $segmentsFile->readLong();
+if ($this->_formatVersion == self::FORMAT_2_3) {
+$docStoreOffset = $segmentsFile->readInt();
+if ($docStoreOffset != (int)0xFFFFFFFF) {
+$docStoreSegment        = $segmentsFile->readString();
+$docStoreIsCompoundFile = $segmentsFile->readByte();
+$docStoreOptions = array('offset'     => $docStoreOffset,
+'segment'    => $docStoreSegment,
+'isCompound' => ($docStoreIsCompoundFile == 1));
+} else {
+$docStoreOptions = null;
+}
+} else {
+$docStoreOptions = null;
+}
+$hasSingleNormFile = $segmentsFile->readByte();
+$numField          = $segmentsFile->readInt();
+$normGens = array();
+if ($numField != (int)0xFFFFFFFF) {
+for ($count1 = 0; $count1 < $numField; $count1++) {
+$normGens[] = $segmentsFile->readLong();
+}
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Separate norm files are not supported. Optimize index to use it with Zend_Search_Lucene.');
+}
+$isCompoundByte     = $segmentsFile->readByte();
+if ($isCompoundByte == 0xFF) {
+// The segment is not a compound file
+$isCompound = false;
+} else if ($isCompoundByte == 0x00) {
+// The status is unknown
+$isCompound = null;
+} else if ($isCompoundByte == 0x01) {
+// The segment is a compound file
+$isCompound = true;
+}
+$this->_docCount += $segSize;
+$this->_segmentInfos[$segName] =
+new Zend_Search_Lucene_Index_SegmentInfo($this->_directory,
+$segName,
+$segSize,
+$delGen,
+$docStoreOptions,
+$hasSingleNormFile,
+$isCompound);
+}
+}
+/**
+* Opens the index.
+*
+* IndexReader constructor needs Directory as a parameter. It should be
+* a string with a path to the index folder or a Directory object.
+*
+* @param Zend_Search_Lucene_Storage_Directory_Filesystem|string $directory
+* @throws Zend_Search_Lucene_Exception
+*/
+public function __construct($directory = null, $create = false)
+{
+if ($directory === null) {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Exception('No index directory specified');
+}
+if (is_string($directory)) {
+require_once 'Zend/Search/Lucene/Storage/Directory/Filesystem.php';
+$this->_directory      = new Zend_Search_Lucene_Storage_Directory_Filesystem($directory);
+$this->_closeDirOnExit = true;
+} else {
+$this->_directory      = $directory;
+$this->_closeDirOnExit = false;
+}
+$this->_segmentInfos = array();
+// Mark index as "under processing" to prevent other processes from premature index cleaning
+Zend_Search_Lucene_LockManager::obtainReadLock($this->_directory);
+$this->_generation = self::getActualGeneration($this->_directory);
+if ($create) {
+require_once 'Zend/Search/Lucene/Exception.php';
+try {
+Zend_Search_Lucene_LockManager::obtainWriteLock($this->_directory);
+} catch (Zend_Search_Lucene_Exception $e) {
+Zend_Search_Lucene_LockManager::releaseReadLock($this->_directory);
+if (strpos($e->getMessage(), 'Can\'t obtain exclusive index lock') === false) {
+throw new Zend_Search_Lucene_Exception($e->getMessage(), $e->getCode(), $e);
+} else {
+throw new Zend_Search_Lucene_Exception('Can\'t create index. It\'s under processing now', 0, $e);
+}
+}
+if ($this->_generation == -1) {
+// Directory doesn't contain existing index, start from 1
+$this->_generation = 1;
+$nameCounter = 0;
+} else {
+// Directory contains existing index
+$segmentsFile = $this->_directory->getFileObject(self::getSegmentFileName($this->_generation));
+$segmentsFile->seek(12); // 12 = 4 (int, file format marker) + 8 (long, index version)
+$nameCounter = $segmentsFile->readInt();
+$this->_generation++;
+}
+require_once 'Zend/Search/Lucene/Index/Writer.php';
+Zend_Search_Lucene_Index_Writer::createIndex($this->_directory, $this->_generation, $nameCounter);
+Zend_Search_Lucene_LockManager::releaseWriteLock($this->_directory);
+}
+if ($this->_generation == -1) {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Index doesn\'t exists in the specified directory.');
+} else if ($this->_generation == 0) {
+$this->_readPre21SegmentsFile();
+} else {
+$this->_readSegmentsFile();
+}
+}
+/**
+* Close current index and free resources
+*/
+private function _close()
+{
+if ($this->_closed) {
+// index is already closed and resources are cleaned up
+return;
+}
+$this->commit();
+// Release "under processing" flag
+Zend_Search_Lucene_LockManager::releaseReadLock($this->_directory);
+if ($this->_closeDirOnExit) {
+$this->_directory->close();
+}
+$this->_directory    = null;
+$this->_writer       = null;
+$this->_segmentInfos = null;
+$this->_closed = true;
+}
+/**
+* Add reference to the index object
+*
+* @internal
+*/
+public function addReference()
+{
+$this->_refCount++;
+}
+/**
+* Remove reference from the index object
+*
+* When reference count becomes zero, index is closed and resources are cleaned up
+*
+* @internal
+*/
+public function removeReference()
+{
+$this->_refCount--;
+if ($this->_refCount == 0) {
+$this->_close();
+}
+}
+/**
+* Object destructor
+*/
+public function __destruct()
+{
+$this->_close();
+}
+/**
+* Returns an instance of Zend_Search_Lucene_Index_Writer for the index
+*
+* @return Zend_Search_Lucene_Index_Writer
+*/
+private function _getIndexWriter()
+{
+if ($this->_writer === null) {
+require_once 'Zend/Search/Lucene/Index/Writer.php';
+$this->_writer = new Zend_Search_Lucene_Index_Writer($this->_directory,
+$this->_segmentInfos,
+$this->_formatVersion);
+}
+return $this->_writer;
+}
+/**
+* Returns the Zend_Search_Lucene_Storage_Directory instance for this index.
+*
+* @return Zend_Search_Lucene_Storage_Directory
+*/
+public function getDirectory()
+{
+return $this->_directory;
+}
+/**
+* Returns the total number of documents in this index (including deleted documents).
+*
+* @return integer
+*/
+public function count()
+{
+return $this->_docCount;
+}
+/**
+* Returns one greater than the largest possible document number.
+* This may be used to, e.g., determine how big to allocate a structure which will have
+* an element for every document number in an index.
+*
+* @return integer
+*/
+public function maxDoc()
+{
+return $this->count();
+}
+/**
+* Returns the total number of non-deleted documents in this index.
+*
+* @return integer
+*/
+public function numDocs()
+{
+$numDocs = 0;
+foreach ($this->_segmentInfos as $segmentInfo) {
+$numDocs += $segmentInfo->numDocs();
+}
+return $numDocs;
+}
+/**
+* Checks, that document is deleted
+*
+* @param integer $id
+* @return boolean
+* @throws Zend_Search_Lucene_Exception    Exception is thrown if $id is out of the range
+*/
+public function isDeleted($id)
+{
+$this->commit();
+if ($id >= $this->_docCount) {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Document id is out of the range.');
+}
+$segmentStartId = 0;
+foreach ($this->_segmentInfos as $segmentInfo) {
+if ($segmentStartId + $segmentInfo->count() > $id) {
+break;
+}
+$segmentStartId += $segmentInfo->count();
+}
+return $segmentInfo->isDeleted($id - $segmentStartId);
+}
+/**
+* Set default search field.
+*
+* Null means, that search is performed through all fields by default
+*
+* Default value is null
+*
+* @param string $fieldName
+*/
+public static function setDefaultSearchField($fieldName)
+{
+self::$_defaultSearchField = $fieldName;
+}
+/**
+* Get default search field.
+*
+* Null means, that search is performed through all fields by default
+*
+* @return string
+*/
+public static function getDefaultSearchField()
+{
+return self::$_defaultSearchField;
+}
+/**
+* Set result set limit.
+*
+* 0 (default) means no limit
+*
+* @param integer $limit
+*/
+public static function setResultSetLimit($limit)
+{
+self::$_resultSetLimit = $limit;
+}
+/**
+* Get result set limit.
+*
+* 0 means no limit
+*
+* @return integer
+*/
+public static function getResultSetLimit()
+{
+return self::$_resultSetLimit;
+}
+/**
+* Set terms per query limit.
+*
+* 0 means no limit
+*
+* @param integer $limit
+*/
+public static function setTermsPerQueryLimit($limit)
+{
+self::$_termsPerQueryLimit = $limit;
+}
+/**
+* Get result set limit.
+*
+* 0 (default) means no limit
+*
+* @return integer
+*/
+public static function getTermsPerQueryLimit()
+{
+return self::$_termsPerQueryLimit;
+}
+/**
+* Retrieve index maxBufferedDocs option
+*
+* maxBufferedDocs is a minimal number of documents required before
+* the buffered in-memory documents are written into a new Segment
+*
+* Default value is 10
+*
+* @return integer
+*/
+public function getMaxBufferedDocs()
+{
+return $this->_getIndexWriter()->maxBufferedDocs;
+}
+/**
+* Set index maxBufferedDocs option
+*
+* maxBufferedDocs is a minimal number of documents required before
+* the buffered in-memory documents are written into a new Segment
+*
+* Default value is 10
+*
+* @param integer $maxBufferedDocs
+*/
+public function setMaxBufferedDocs($maxBufferedDocs)
+{
+$this->_getIndexWriter()->maxBufferedDocs = $maxBufferedDocs;
+}
+/**
+* Retrieve index maxMergeDocs option
+*
+* maxMergeDocs is a largest number of documents ever merged by addDocument().
+* Small values (e.g., less than 10,000) are best for interactive indexing,
+* as this limits the length of pauses while indexing to a few seconds.
+* Larger values are best for batched indexing and speedier searches.
+*
+* Default value is PHP_INT_MAX
+*
+* @return integer
+*/
+public function getMaxMergeDocs()
+{
+return $this->_getIndexWriter()->maxMergeDocs;
+}
+/**
+* Set index maxMergeDocs option
+*
+* maxMergeDocs is a largest number of documents ever merged by addDocument().
+* Small values (e.g., less than 10,000) are best for interactive indexing,
+* as this limits the length of pauses while indexing to a few seconds.
+* Larger values are best for batched indexing and speedier searches.
+*
+* Default value is PHP_INT_MAX
+*
+* @param integer $maxMergeDocs
+*/
+public function setMaxMergeDocs($maxMergeDocs)
+{
+$this->_getIndexWriter()->maxMergeDocs = $maxMergeDocs;
+}
+/**
+* Retrieve index mergeFactor option
+*
+* mergeFactor determines how often segment indices are merged by addDocument().
+* With smaller values, less RAM is used while indexing,
+* and searches on unoptimized indices are faster,
+* but indexing speed is slower.
+* With larger values, more RAM is used during indexing,
+* and while searches on unoptimized indices are slower,
+* indexing is faster.
+* Thus larger values (> 10) are best for batch index creation,
+* and smaller values (< 10) for indices that are interactively maintained.
+*
+* Default value is 10
+*
+* @return integer
+*/
+public function getMergeFactor()
+{
+return $this->_getIndexWriter()->mergeFactor;
+}
+/**
+* Set index mergeFactor option
+*
+* mergeFactor determines how often segment indices are merged by addDocument().
+* With smaller values, less RAM is used while indexing,
+* and searches on unoptimized indices are faster,
+* but indexing speed is slower.
+* With larger values, more RAM is used during indexing,
+* and while searches on unoptimized indices are slower,
+* indexing is faster.
+* Thus larger values (> 10) are best for batch index creation,
+* and smaller values (< 10) for indices that are interactively maintained.
+*
+* Default value is 10
+*
+* @param integer $maxMergeDocs
+*/
+public function setMergeFactor($mergeFactor)
+{
+$this->_getIndexWriter()->mergeFactor = $mergeFactor;
+}
+/**
+* Performs a query against the index and returns an array
+* of Zend_Search_Lucene_Search_QueryHit objects.
+* Input is a string or Zend_Search_Lucene_Search_Query.
+*
+* @param Zend_Search_Lucene_Search_QueryParser|string $query
+* @return array Zend_Search_Lucene_Search_QueryHit
+* @throws Zend_Search_Lucene_Exception
+*/
+public function find($query)
+{
+if (is_string($query)) {
+require_once 'Zend/Search/Lucene/Search/QueryParser.php';
+$query = Zend_Search_Lucene_Search_QueryParser::parse($query);
+}
+if (!$query instanceof Zend_Search_Lucene_Search_Query) {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Query must be a string or Zend_Search_Lucene_Search_Query object');
+}
+$this->commit();
+$hits   = array();
+$scores = array();
+$ids    = array();
+$query = $query->rewrite($this)->optimize($this);
+$query->execute($this);
+$topScore = 0;
+/** Zend_Search_Lucene_Search_QueryHit */
+require_once 'Zend/Search/Lucene/Search/QueryHit.php';
+foreach ($query->matchedDocs() as $id => $num) {
+$docScore = $query->score($id, $this);
+if( $docScore != 0 ) {
+$hit = new Zend_Search_Lucene_Search_QueryHit($this);
+$hit->id = $id;
+$hit->score = $docScore;
+$hits[]   = $hit;
+$ids[]    = $id;
+$scores[] = $docScore;
+if ($docScore > $topScore) {
+$topScore = $docScore;
+}
+}
+if (self::$_resultSetLimit != 0  &&  count($hits) >= self::$_resultSetLimit) {
+break;
+}
+}
+if (count($hits) == 0) {
+// skip sorting, which may cause a error on empty index
+return array();
+}
+if ($topScore > 1) {
+foreach ($hits as $hit) {
+$hit->score /= $topScore;
+}
+}
+if (func_num_args() == 1) {
+// sort by scores
+array_multisort($scores, SORT_DESC, SORT_NUMERIC,
+$ids,    SORT_ASC,  SORT_NUMERIC,
+$hits);
+} else {
+// sort by given field names
+$argList    = func_get_args();
+$fieldNames = $this->getFieldNames();
+$sortArgs   = array();
+// PHP 5.3 now expects all arguments to array_multisort be passed by
+// reference (if it's invoked through call_user_func_array());
+// since constants can't be passed by reference, create some placeholder variables.
+$sortReg    = SORT_REGULAR;
+$sortAsc    = SORT_ASC;
+$sortNum    = SORT_NUMERIC;
+$sortFieldValues = array();
+require_once 'Zend/Search/Lucene/Exception.php';
+for ($count = 1; $count < count($argList); $count++) {
+$fieldName = $argList[$count];
+if (!is_string($fieldName)) {
+throw new Zend_Search_Lucene_Exception('Field name must be a string.');
+}
+if (strtolower($fieldName) == 'score') {
+$sortArgs[] = &$scores;
+} else {
+if (!in_array($fieldName, $fieldNames)) {
+throw new Zend_Search_Lucene_Exception('Wrong field name.');
+}
+if (!isset($sortFieldValues[$fieldName])) {
+$valuesArray = array();
+foreach ($hits as $hit) {
+try {
+$value = $hit->getDocument()->getFieldValue($fieldName);
+} catch (Zend_Search_Lucene_Exception $e) {
+if (strpos($e->getMessage(), 'not found') === false) {
+throw new Zend_Search_Lucene_Exception($e->getMessage(), $e->getCode(), $e);
+} else {
+$value = null;
+}
+}
+$valuesArray[] = $value;
+}
+// Collect loaded values in $sortFieldValues
+// Required for PHP 5.3 which translates references into values when source
+// variable is destroyed
+$sortFieldValues[$fieldName] = $valuesArray;
+}
+$sortArgs[] = &$sortFieldValues[$fieldName];
+}
+if ($count + 1 < count($argList)  &&  is_integer($argList[$count+1])) {
+$count++;
+$sortArgs[] = &$argList[$count];
+if ($count + 1 < count($argList)  &&  is_integer($argList[$count+1])) {
+$count++;
+$sortArgs[] = &$argList[$count];
+} else {
+if ($argList[$count] == SORT_ASC  || $argList[$count] == SORT_DESC) {
+$sortArgs[] = &$sortReg;
+} else {
+$sortArgs[] = &$sortAsc;
+}
+}
+} else {
+$sortArgs[] = &$sortAsc;
+$sortArgs[] = &$sortReg;
+}
+}
+// Sort by id's if values are equal
+$sortArgs[] = &$ids;
+$sortArgs[] = &$sortAsc;
+$sortArgs[] = &$sortNum;
+// Array to be sorted
+$sortArgs[] = &$hits;
+// Do sort
+call_user_func_array('array_multisort', $sortArgs);
+}
+return $hits;
+}
+/**
+* Returns a list of all unique field names that exist in this index.
+*
+* @param boolean $indexed
+* @return array
+*/
+public function getFieldNames($indexed = false)
+{
+$result = array();
+foreach( $this->_segmentInfos as $segmentInfo ) {
+$result = array_merge($result, $segmentInfo->getFields($indexed));
+}
+return $result;
+}
+/**
+* Returns a Zend_Search_Lucene_Document object for the document
+* number $id in this index.
+*
+* @param integer|Zend_Search_Lucene_Search_QueryHit $id
+* @return Zend_Search_Lucene_Document
+* @throws Zend_Search_Lucene_Exception    Exception is thrown if $id is out of the range
+*/
+public function getDocument($id)
+{
+if ($id instanceof Zend_Search_Lucene_Search_QueryHit) {
+/* @var $id Zend_Search_Lucene_Search_QueryHit */
+$id = $id->id;
+}
+if ($id >= $this->_docCount) {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Document id is out of the range.');
+}
+$segmentStartId = 0;
+foreach ($this->_segmentInfos as $segmentInfo) {
+if ($segmentStartId + $segmentInfo->count() > $id) {
+break;
+}
+$segmentStartId += $segmentInfo->count();
+}
+$fdxFile = $segmentInfo->openCompoundFile('.fdx');
+$fdxFile->seek(($id-$segmentStartId)*8, SEEK_CUR);
+$fieldValuesPosition = $fdxFile->readLong();
+$fdtFile = $segmentInfo->openCompoundFile('.fdt');
+$fdtFile->seek($fieldValuesPosition, SEEK_CUR);
+$fieldCount = $fdtFile->readVInt();
+$doc = new Zend_Search_Lucene_Document();
+for ($count = 0; $count < $fieldCount; $count++) {
+$fieldNum = $fdtFile->readVInt();
+$bits = $fdtFile->readByte();
+$fieldInfo = $segmentInfo->getField($fieldNum);
+if (!($bits & 2)) { // Text data
+$field = new Zend_Search_Lucene_Field($fieldInfo->name,
+$fdtFile->readString(),
+'UTF-8',
+true,
+$fieldInfo->isIndexed,
+$bits & 1 );
+} else {            // Binary data
+$field = new Zend_Search_Lucene_Field($fieldInfo->name,
+$fdtFile->readBinary(),
+'',
+true,
+$fieldInfo->isIndexed,
+$bits & 1,
+true );
+}
+$doc->addField($field);
+}
+return $doc;
+}
+/**
+* Returns true if index contain documents with specified term.
+*
+* Is used for query optimization.
+*
+* @param Zend_Search_Lucene_Index_Term $term
+* @return boolean
+*/
+public function hasTerm(Zend_Search_Lucene_Index_Term $term)
+{
+foreach ($this->_segmentInfos as $segInfo) {
+if ($segInfo->getTermInfo($term) !== null) {
+return true;
+}
+}
+return false;
+}
+/**
+* Returns IDs of all documents containing term.
+*
+* @param Zend_Search_Lucene_Index_Term $term
+* @param Zend_Search_Lucene_Index_DocsFilter|null $docsFilter
+* @return array
+*/
+public function termDocs(Zend_Search_Lucene_Index_Term $term, $docsFilter = null)
+{
+$subResults = array();
+$segmentStartDocId = 0;
+foreach ($this->_segmentInfos as $segmentInfo) {
+$subResults[] = $segmentInfo->termDocs($term, $segmentStartDocId, $docsFilter);
+$segmentStartDocId += $segmentInfo->count();
+}
+if (count($subResults) == 0) {
+return array();
+} else if (count($subResults) == 1) {
+// Index is optimized (only one segment)
+// Do not perform array reindexing
+return reset($subResults);
+} else {
+$result = call_user_func_array('array_merge', $subResults);
+}
+return $result;
+}
+/**
+* Returns documents filter for all documents containing term.
+*
+* It performs the same operation as termDocs, but return result as
+* Zend_Search_Lucene_Index_DocsFilter object
+*
+* @param Zend_Search_Lucene_Index_Term $term
+* @param Zend_Search_Lucene_Index_DocsFilter|null $docsFilter
+* @return Zend_Search_Lucene_Index_DocsFilter
+*/
+public function termDocsFilter(Zend_Search_Lucene_Index_Term $term, $docsFilter = null)
+{
+$segmentStartDocId = 0;
+$result = new Zend_Search_Lucene_Index_DocsFilter();
+foreach ($this->_segmentInfos as $segmentInfo) {
+$subResults[] = $segmentInfo->termDocs($term, $segmentStartDocId, $docsFilter);
+$segmentStartDocId += $segmentInfo->count();
+}
+if (count($subResults) == 0) {
+return array();
+} else if (count($subResults) == 1) {
+// Index is optimized (only one segment)
+// Do not perform array reindexing
+return reset($subResults);
+} else {
+$result = call_user_func_array('array_merge', $subResults);
+}
+return $result;
+}
+/**
+* Returns an array of all term freqs.
+* Result array structure: array(docId => freq, ...)
+*
+* @param Zend_Search_Lucene_Index_Term $term
+* @param Zend_Search_Lucene_Index_DocsFilter|null $docsFilter
+* @return integer
+*/
+public function termFreqs(Zend_Search_Lucene_Index_Term $term, $docsFilter = null)
+{
+$result = array();
+$segmentStartDocId = 0;
+foreach ($this->_segmentInfos as $segmentInfo) {
+$result += $segmentInfo->termFreqs($term, $segmentStartDocId, $docsFilter);
+$segmentStartDocId += $segmentInfo->count();
+}
+return $result;
+}
+/**
+* Returns an array of all term positions in the documents.
+* Result array structure: array(docId => array(pos1, pos2, ...), ...)
+*
+* @param Zend_Search_Lucene_Index_Term $term
+* @param Zend_Search_Lucene_Index_DocsFilter|null $docsFilter
+* @return array
+*/
+public function termPositions(Zend_Search_Lucene_Index_Term $term, $docsFilter = null)
+{
+$result = array();
+$segmentStartDocId = 0;
+foreach ($this->_segmentInfos as $segmentInfo) {
+$result += $segmentInfo->termPositions($term, $segmentStartDocId, $docsFilter);
+$segmentStartDocId += $segmentInfo->count();
+}
+return $result;
+}
+/**
+* Returns the number of documents in this index containing the $term.
+*
+* @param Zend_Search_Lucene_Index_Term $term
+* @return integer
+*/
+public function docFreq(Zend_Search_Lucene_Index_Term $term)
+{
+$result = 0;
+foreach ($this->_segmentInfos as $segInfo) {
+$termInfo = $segInfo->getTermInfo($term);
+if ($termInfo !== null) {
+$result += $termInfo->docFreq;
+}
+}
+return $result;
+}
+/**
+* Retrive similarity used by index reader
+*
+* @return Zend_Search_Lucene_Search_Similarity
+*/
+public function getSimilarity()
+{
+/** Zend_Search_Lucene_Search_Similarity */
+require_once 'Zend/Search/Lucene/Search/Similarity.php';
+return Zend_Search_Lucene_Search_Similarity::getDefault();
+}
+/**
+* Returns a normalization factor for "field, document" pair.
+*
+* @param integer $id
+* @param string $fieldName
+* @return float
+*/
+public function norm($id, $fieldName)
+{
+if ($id >= $this->_docCount) {
+return null;
+}
+$segmentStartId = 0;
+foreach ($this->_segmentInfos as $segInfo) {
+if ($segmentStartId + $segInfo->count() > $id) {
+break;
+}
+$segmentStartId += $segInfo->count();
+}
+if ($segInfo->isDeleted($id - $segmentStartId)) {
+return 0;
+}
+return $segInfo->norm($id - $segmentStartId, $fieldName);
+}
+/**
+* Returns true if any documents have been deleted from this index.
+*
+* @return boolean
+*/
+public function hasDeletions()
+{
+foreach ($this->_segmentInfos as $segmentInfo) {
+if ($segmentInfo->hasDeletions()) {
+return true;
+}
+}
+return false;
+}
+/**
+* Deletes a document from the index.
+* $id is an internal document id
+*
+* @param integer|Zend_Search_Lucene_Search_QueryHit $id
+* @throws Zend_Search_Lucene_Exception
+*/
+public function delete($id)
+{
+if ($id instanceof Zend_Search_Lucene_Search_QueryHit) {
+/* @var $id Zend_Search_Lucene_Search_QueryHit */
+$id = $id->id;
+}
+if ($id >= $this->_docCount) {
+require_once 'Zend/Search/Lucene/Exception.php';
+throw new Zend_Search_Lucene_Exception('Document id is out of the range.');
+}
+$segmentStartId = 0;
+foreach ($this->_segmentInfos as $segmentInfo) {
+if ($segmentStartId + $segmentInfo->count() > $id) {
+break;
+}
+$segmentStartId += $segmentInfo->count();
+}
+$segmentInfo->delete($id - $segmentStartId);
+$this->_hasChanges = true;
+}
+/**
+* Adds a document to this index.
+*
+* @param Zend_Search_Lucene_Document $document
+*/
+public function addDocument(Zend_Search_Lucene_Document $document)
+{
+$this->_getIndexWriter()->addDocument($document);
+$this->_docCount++;
+$this->_hasChanges = true;
+}
+/**
+* Update document counter
+*/
+private function _updateDocCount()
+{
+$this->_docCount = 0;
+foreach ($this->_segmentInfos as $segInfo) {
+$this->_docCount += $segInfo->count();
+}
+}
+/**
+* Commit changes resulting from delete() or undeleteAll() operations.
+*
+* @todo undeleteAll processing.
+*/
+public function commit()
+{
+if ($this->_hasChanges) {
+$this->_getIndexWriter()->commit();
+$this->_updateDocCount();
+$this->_hasChanges = false;
+}
+}
+/**
+* Optimize index.
+*
+* Merges all segments into one
+*/
+public function optimize()
+{
+// Commit changes if any changes have been made
+$this->commit();
+if (count($this->_segmentInfos) > 1 || $this->hasDeletions()) {
+$this->_getIndexWriter()->optimize();
+$this->_updateDocCount();
+}
+}
+/**
+* Returns an array of all terms in this index.
+*
+* @return array
+*/
+public function terms()
+{
+$result = array();
+/** Zend_Search_Lucene_Index_TermsPriorityQueue */
+require_once 'Zend/Search/Lucene/Index/TermsPriorityQueue.php';
+$segmentInfoQueue = new Zend_Search_Lucene_Index_TermsPriorityQueue();
+foreach ($this->_segmentInfos as $segmentInfo) {
+$segmentInfo->resetTermsStream();
+// Skip "empty" segments
+if ($segmentInfo->currentTerm() !== null) {
+$segmentInfoQueue->put($segmentInfo);
+}
+}
+while (($segmentInfo = $segmentInfoQueue->pop()) !== null) {
+if ($segmentInfoQueue->top() === null ||
+$segmentInfoQueue->top()->currentTerm()->key() !=
+$segmentInfo->currentTerm()->key()) {
+// We got new term
+$result[] = $segmentInfo->currentTerm();
+}
+if ($segmentInfo->nextTerm() !== null) {
+// Put segment back into the priority queue
+$segmentInfoQueue->put($segmentInfo);
+}
+}
+return $result;
+}
+/**
+* Terms stream priority queue object
+*
+* @var Zend_Search_Lucene_TermStreamsPriorityQueue
+*/
+private $_termsStream = null;
+/**
+* Reset terms stream.
+*/
+public function resetTermsStream()
+{
+if ($this->_termsStream === null) {
+/** Zend_Search_Lucene_TermStreamsPriorityQueue */
+require_once 'Zend/Search/Lucene/TermStreamsPriorityQueue.php';
+$this->_termsStream = new Zend_Search_Lucene_TermStreamsPriorityQueue($this->_segmentInfos);
+} else {
+$this->_termsStream->resetTermsStream();
+}
+}
+/**
+* Skip terms stream up to the specified term preffix.
+*
+* Prefix contains fully specified field info and portion of searched term
+*
+* @param Zend_Search_Lucene_Index_Term $prefix
+*/
+public function skipTo(Zend_Search_Lucene_Index_Term $prefix)
+{
+$this->_termsStream->skipTo($prefix);
+}
+/**
+* Scans terms dictionary and returns next term
+*
+* @return Zend_Search_Lucene_Index_Term|null
+*/
+public function nextTerm()
+{
+return $this->_termsStream->nextTerm();
+}
+/**
+* Returns term in current position
+*
+* @return Zend_Search_Lucene_Index_Term|null
+*/
+public function currentTerm()
+{
+return $this->_termsStream->currentTerm();
+}
+/**
+* Close terms stream
+*
+* Should be used for resources clean up if stream is not read up to the end
+*/
+public function closeTermsStream()
+{
+$this->_termsStream->closeTermsStream();
+$this->_termsStream = null;
+}
+/*************************************************************************
+@todo UNIMPLEMENTED
+*************************************************************************/
+/**
+* Undeletes all documents currently marked as deleted in this index.
+*
+* @todo Implementation
+*/
+public function undeleteAll()
+{}
+}