Subversion-Projekte lars-tiefland.php_share

<?php

/*

 *  $Id$

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * This software consists of voluntary contributions made by many individuals

 * and is licensed under the LGPL. For more information, see

 * <http://www.doctrine-project.org>.

 */

/**

 * Doctrine_Search

 *

 * @package     Doctrine

 * @subpackage  Search

 * @author      Konsta Vesterinen <kvesteri@cc.hut.fi>

 * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL

 * @version     $Revision$

 * @link        www.doctrine-project.org

 * @since       1.0

 */

class Doctrine_Search extends Doctrine_Record_Generator

{

    const INDEX_FILES = 0;

    const INDEX_TABLES = 1;

    protected $_options = array('generateFiles'    => false,

                                'analyzer'         => 'Doctrine_Search_Analyzer_Standard',

                                'analyzer_options' => array(),

                                'type'             => self::INDEX_TABLES,

                                'className'        => '%CLASS%Index',

                                'generatePath'     => false,

                                'table'            => null,

                                'batchUpdates'     => false,

                                'pluginTable'      => false,

                                'fields'           => array(),

                                'connection'       => null,

                                'children'         => array(),

                                'cascadeDelete'    => true,

                                'appLevelDelete'   => false);

    /**

     * __construct

     *

     * @param array $options

     * @return void

     */

    public function __construct(array $options)

    {

        $this->_options = Doctrine_Lib::arrayDeepMerge($this->_options, $options);

        if ( ! isset($this->_options['analyzer'])) {

            $this->_options['analyzer'] = 'Doctrine_Search_Analyzer_Standard';

        }

        if ( ! isset($this->_options['analyzer_options'])) {

            $this->_options['analyzer_options'] = array();

        }

        $this->_options['analyzer'] = new $this->_options['analyzer']($this->_options['analyzer_options']);

    }

    public function buildTable()

    {

        $result = parent::buildTable();

        if ( ! isset($this->_options['connection'])) {

            $manager = Doctrine_Manager::getInstance();

            $this->_options['connection'] = $manager->getConnectionForComponent($this->_options['table']->getComponentName());

            $manager->bindComponent($this->_options['className'], $this->_options['connection']->getName());

        }

        return $result;

    }

    /**

     * Searchable keyword search

     *

     * @param string $string Keyword string to search for

     * @param Doctrine_Query $query Query object to alter. Adds where condition to limit the results using the search index

     * @return array    ids and relevancy

     */

    public function search($string, $query = null)

    {

        $q = new Doctrine_Search_Query($this->_table);

        if ($query instanceof Doctrine_Query) {

            $q->query($string, false);

            $newQuery = $query->copy();

            $query->getSqlQuery();

            $key = (array) $this->getOption('table')->getIdentifier();

            $newQuery->addWhere($query->getRootAlias() . '.'.current($key).' IN (SQL:' . $q->getSqlQuery() . ')', $q->getParams());

            return $newQuery;

        } else {

            if ( ! isset($this->_options['connection'])) {

                $this->_options['connection'] = $this->_table->getConnection();

            }

            $q->query($string);

            return $this->_options['connection']->fetchAll($q->getSqlQuery(), $q->getParams());

        }

    }

    /**

     * analyze a text in the encoding format

     *

     * @param string $text

     * @param string $encoding

     * @return void

     */

    public function analyze($text, $encoding = null)

    {

        return $this->_options['analyzer']->analyze($text, $encoding);

    }

    /**

     * updateIndex

     * updates the index

     *

     * @param Doctrine_Record $record

     * @return integer

     */

    public function updateIndex(array $data, $encoding = null)

    {

        $this->initialize($this->_options['table']);

        $fields = $this->getOption('fields');

        $class  = $this->getOption('className');

        $name   = $this->getOption('table')->getComponentName();

        $conn   = $this->getOption('table')->getConnection();

        $identifier = $this->_options['table']->getIdentifier();

        $q = Doctrine_Core::getTable($class)

            ->createQuery()

            ->delete();

        foreach ((array) $identifier as $id) {

            $q->addWhere($id . ' = ?', array($data[$id]));

        }

        $q->execute();

        if ($this->_options['batchUpdates'] === true) {

            $index = new $class();

            foreach ((array) $this->_options['table']->getIdentifier() as $id) {

                $index->$id = $data[$id];

            }

            $index->save();

        } else {

            foreach ($fields as $field) {

                $value = isset($data[$field]) ? $data[$field] : null;

                $terms = $this->analyze($value, $encoding);

                foreach ($terms as $pos => $term) {

                    $index = new $class();

                    $index->keyword = $term;

                    $index->position = $pos;

                    $index->field = $field;

                    foreach ((array) $this->_options['table']->getIdentifier() as $id) {

                        $index->$id = $data[$id];

                    }

                    $index->save();

                    $index->free(true);

                }

            }

        }

    }

    /**

     * readTableData

     *

     * @param mixed $limit

     * @param mixed $offset

     * @return Doctrine_Collection The collection of results

     */

    public function readTableData($limit = null, $offset = null)

    {

        $this->initialize($this->_options['table']);

        $conn      = $this->_options['table']->getConnection();

        $tableName = $this->_options['table']->getTableName();

        $id        = current($this->_options['table']->getIdentifierColumnNames());

        $tableId   = current($this->_table->getIdentifierColumnNames());

        $query = 'SELECT * FROM ' . $conn->quoteIdentifier($tableName)

               . ' WHERE ' . $conn->quoteIdentifier($id)

               . ' IN (SELECT ' . $conn->quoteIdentifier($tableId)

               . ' FROM ' . $conn->quoteIdentifier($this->_table->getTableName())

               . ' WHERE keyword = \'\') OR ' . $conn->quoteIdentifier($id)

               . ' NOT IN (SELECT ' . $conn->quoteIdentifier($tableId)

               . ' FROM ' . $conn->quoteIdentifier($this->_table->getTableName()) . ')';

        $query = $conn->modifyLimitQuery($query, $limit, $offset);

        return $conn->fetchAll($query);

    }

    /**

     * batchUpdateIndex

     *

     * @param mixed $limit

     * @param mixed $offset

     * @return void

     */

    public function batchUpdateIndex($limit = null, $offset = null, $encoding = null)

    {

        $table = $this->_options['table'];

        $this->initialize($table);

        $id        = $table->getIdentifierColumnNames();

        $class     = $this->_options['className'];

        $fields    = $this->_options['fields'];

        $conn      = $this->_options['table']->getConnection();

        for ($i = 0; $i < count($fields); $i++) {

            $fields[$i] = $table->getColumnName($fields[$i], $fields[$i]);

        }

        $rows = $this->readTableData($limit, $offset);

        $ids = array();

        foreach ($rows as $row) {

            foreach ($id as $idcol) {

                $ids[] = $row[$idcol];

            }

        }

        if (count($ids) > 0)

        {

            $sql = 'DELETE FROM ' . $conn->quoteIdentifier($this->_table->getTableName());

            if (count($id) == 1) {

                $placeholders = str_repeat('?, ', count($ids));

                $placeholders = substr($placeholders, 0, strlen($placeholders) - 2);

                $sql .= ' WHERE ' . $conn->quoteIdentifier($table->getIdentifier()) . ' IN (' . substr($placeholders, 0) . ')';

            } else {

                // composite primary key

                $placeholders = '';

                foreach ($table->getIdentifier() as $id) {

                    $placeholders .= $conn->quoteIdentifier($id) . ' = ? AND ';

                }

                $placeholders = '(' . substr($placeholders, 0, strlen($placeholders) - 5) . ') OR ';

                $placeholders = str_repeat($placeholders, count($rows));

                $placeholders = substr($placeholders, 0, strlen($placeholders) - 4);

                $sql .= ' WHERE ' . $placeholders;

            }

            $conn->exec($sql, $ids);

        }

        foreach ($rows as $row) {

            $conn->beginTransaction();

            try {

                foreach ($fields as $field) {

                    $data  = $row[$field];

                    $terms = $this->analyze($data, $encoding);

                    foreach ($terms as $pos => $term) {

                        $index = new $class();

                        $index->keyword = $term;

                        $index->position = $pos;

                        $index->field = $field;

                        foreach ((array) $table->getIdentifier() as $identifier) {

                            $index->$identifier = $row[$table->getColumnName($identifier, $identifier)];

                        }

                        $index->save();

                        $index->free(true);

                    }

                }

                $conn->commit();

            } catch (Doctrine_Exception $e) {

                $conn->rollback();

                throw $e;

            }

        }

    }

    /**

     * buildDefinition

     *

     * @return void

     */

    public function setTableDefinition()

    {

    	if ( ! isset($this->_options['table'])) {

    	    throw new Doctrine_Record_Exception("Unknown option 'table'.");

    	}

        $componentName = $this->_options['table']->getComponentName();

        $className = $this->getOption('className');

        $autoLoad = (bool) ($this->_options['generateFiles']);

        if (class_exists($className, $autoLoad)) {

            return false;

        }

        // move any columns currently in the primary key to the end

        // So that 'keyword' is the first field in the table

        $previousIdentifier = array();

        foreach ($this->_table->getIdentifier() as $name) {

            $previousIdentifier[$name] = $this->_table->getColumnDefinition($name);

            $this->_table->removeColumn($name);

        }

        $columns = array('keyword'  => array('type'    => 'string',

                                             'length'  => 200,

                                             'primary' => true,

                                             ),

                         'field'    => array('type'    => 'string',

                                             'length'  => 50,

                                             'primary' => true),

                         'position' => array('type'    => 'integer',

                                             'length'  => 8,

                                             'primary' => true,

                                             ));

        $this->hasColumns($columns);

        $this->hasColumns($previousIdentifier);

    }

}