<?php

/*

 * 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>.

 */

namespace Doctrine\ORM\Query;

use Doctrine\DBAL\LockMode,

    Doctrine\ORM\Mapping\ClassMetadata,

    Doctrine\ORM\Query,

    Doctrine\ORM\Query\QueryException;

/**

 * The SqlWalker is a TreeWalker that walks over a DQL AST and constructs

 * the corresponding SQL.

 *

 * @author Roman Borschel <roman@code-factory.org>

 * @author Benjamin Eberlei <kontakt@beberlei.de>

 * @since 2.0

 * @todo Rename: SQLWalker

 */

class SqlWalker implements TreeWalker

{

    /**

     * @var ResultSetMapping

     */

    private $_rsm;

    /** Counters for generating unique column aliases, table aliases and parameter indexes. */

    private $_aliasCounter = 0;

    private $_tableAliasCounter = 0;

    private $_scalarResultCounter = 1;

    private $_sqlParamIndex = 0;

    /**

     * @var ParserResult

     */

    private $_parserResult;

    /**

     * @var EntityManager

     */

    private $_em;

    /**

     * @var Doctrine\DBAL\Connection

     */

    private $_conn;

    /**

     * @var AbstractQuery

     */

    private $_query;

    private $_tableAliasMap = array();

    /** Map from result variable names to their SQL column alias names. */

    private $_scalarResultAliasMap = array();

    /** Map of all components/classes that appear in the DQL query. */

    private $_queryComponents;

    /** A list of classes that appear in non-scalar SelectExpressions. */

    private $_selectedClasses = array();

    /**

     * The DQL alias of the root class of the currently traversed query.

     */

    private $_rootAliases = array();

    /**

     * Flag that indicates whether to generate SQL table aliases in the SQL.

     * These should only be generated for SELECT queries, not for UPDATE/DELETE.

     */

    private $_useSqlTableAliases = true;

    /**

     * The database platform abstraction.

     *

     * @var AbstractPlatform

     */

    private $_platform;

    /**

     * {@inheritDoc}

     */

    public function __construct($query, $parserResult, array $queryComponents)

    {

        $this->_query = $query;

        $this->_parserResult = $parserResult;

        $this->_queryComponents = $queryComponents;

        $this->_rsm = $parserResult->getResultSetMapping();

        $this->_em = $query->getEntityManager();

        $this->_conn = $this->_em->getConnection();

        $this->_platform = $this->_conn->getDatabasePlatform();

    }

    /**

     * Gets the Query instance used by the walker.

     *

     * @return Query.

     */

    public function getQuery()

    {

        return $this->_query;

    }

    /**

     * Gets the Connection used by the walker.

     *

     * @return Connection

     */

    public function getConnection()

    {

        return $this->_conn;

    }

    /**

     * Gets the EntityManager used by the walker.

     *

     * @return EntityManager

     */

    public function getEntityManager()

    {

        return $this->_em;

    }

    /**

     * Gets the information about a single query component.

     *

     * @param string $dqlAlias The DQL alias.

     * @return array

     */

    public function getQueryComponent($dqlAlias)

    {

        return $this->_queryComponents[$dqlAlias];

    }

    /**

     * Gets an executor that can be used to execute the result of this walker.

     *

     * @return AbstractExecutor

     */

    public function getExecutor($AST)

    {

        $isDeleteStatement = $AST instanceof AST\DeleteStatement;

        $isUpdateStatement = $AST instanceof AST\UpdateStatement;

        if ($isDeleteStatement) {

            $primaryClass = $this->_em->getClassMetadata(

                $AST->deleteClause->abstractSchemaName

            );

            if ($primaryClass->isInheritanceTypeJoined()) {

                return new Exec\MultiTableDeleteExecutor($AST, $this);

            } else {

                return new Exec\SingleTableDeleteUpdateExecutor($AST, $this);

            }

        } else if ($isUpdateStatement) {

            $primaryClass = $this->_em->getClassMetadata(

                $AST->updateClause->abstractSchemaName

            );

            if ($primaryClass->isInheritanceTypeJoined()) {

                return new Exec\MultiTableUpdateExecutor($AST, $this);

            } else {

                return new Exec\SingleTableDeleteUpdateExecutor($AST, $this);

            }

        }

        return new Exec\SingleSelectExecutor($AST, $this);

    }

    /**

     * Generates a unique, short SQL table alias.

     *

     * @param string $tableName Table name

     * @param string $dqlAlias The DQL alias.

     * @return string Generated table alias.

     */

    public function getSQLTableAlias($tableName, $dqlAlias = '')

    {

        $tableName .= ($dqlAlias) ? '@[' . $dqlAlias . ']' : '';

        if ( ! isset($this->_tableAliasMap[$tableName])) {

            $this->_tableAliasMap[$tableName] = strtolower(substr($tableName, 0, 1)) . $this->_tableAliasCounter++ . '_';

        }

        return $this->_tableAliasMap[$tableName];

    }

    /**

     * Forces the SqlWalker to use a specific alias for a table name, rather than

     * generating an alias on its own.

     *

     * @param string $tableName

     * @param string $alias

     * @param string $dqlAlias

     * @return string

     */

    public function setSQLTableAlias($tableName, $alias, $dqlAlias = '')

    {

        $tableName .= ($dqlAlias) ? '@[' . $dqlAlias . ']' : '';

        $this->_tableAliasMap[$tableName] = $alias;

        return $alias;

    }

    /**

     * Gets an SQL column alias for a column name.

     *

     * @param string $columnName

     * @return string

     */

    public function getSQLColumnAlias($columnName)

    {

        return $columnName . $this->_aliasCounter++;

    }

    /**

     * Generates the SQL JOINs that are necessary for Class Table Inheritance

     * for the given class.

     *

     * @param ClassMetadata $class The class for which to generate the joins.

     * @param string $dqlAlias The DQL alias of the class.

     * @return string The SQL.

     */

    private function _generateClassTableInheritanceJoins($class, $dqlAlias)

    {

        $sql = '';

        $baseTableAlias = $this->getSQLTableAlias($class->table['name'], $dqlAlias);

        // INNER JOIN parent class tables

        foreach ($class->parentClasses as $parentClassName) {

            $parentClass = $this->_em->getClassMetadata($parentClassName);

            $tableAlias = $this->getSQLTableAlias($parentClass->table['name'], $dqlAlias);

            // If this is a joined association we must use left joins to preserve the correct result.

            $sql .= isset($this->_queryComponents[$dqlAlias]['relation']) ? ' LEFT ' : ' INNER ';

            $sql .= 'JOIN ' . $parentClass->getQuotedTableName($this->_platform)

                  . ' ' . $tableAlias . ' ON ';

            $first = true;

            foreach ($class->identifier as $idField) {

                if ($first) $first = false; else $sql .= ' AND ';

                $columnName = $class->getQuotedColumnName($idField, $this->_platform);

                $sql .= $baseTableAlias . '.' . $columnName

                      . ' = '

                      . $tableAlias . '.' . $columnName;

            }

        }

        // LEFT JOIN subclass tables, if partial objects disallowed.

        if ( ! $this->_query->getHint(Query::HINT_FORCE_PARTIAL_LOAD)) {

            foreach ($class->subClasses as $subClassName) {

                $subClass = $this->_em->getClassMetadata($subClassName);

                $tableAlias = $this->getSQLTableAlias($subClass->table['name'], $dqlAlias);

                $sql .= ' LEFT JOIN ' . $subClass->getQuotedTableName($this->_platform)

                        . ' ' . $tableAlias . ' ON ';

                $first = true;

                foreach ($class->identifier as $idField) {

                    if ($first) $first = false; else $sql .= ' AND ';

                    $columnName = $class->getQuotedColumnName($idField, $this->_platform);

                    $sql .= $baseTableAlias . '.' . $columnName

                            . ' = '

                            . $tableAlias . '.' . $columnName;

                }

            }

        }

        return $sql;

    }

    private function _generateOrderedCollectionOrderByItems()

    {

        $sql = '';

        foreach ($this->_selectedClasses AS $dqlAlias => $class) {

            $qComp = $this->_queryComponents[$dqlAlias];

            if (isset($qComp['relation']['orderBy'])) {

                foreach ($qComp['relation']['orderBy'] AS $fieldName => $orientation) {

                    if ($qComp['metadata']->isInheritanceTypeJoined()) {

                        $tableName = $this->_em->getUnitOfWork()->getEntityPersister($class->name)->getOwningTable($fieldName);

                    } else {

                        $tableName = $qComp['metadata']->table['name'];

                    }

                    if ($sql != '') {

                        $sql .= ', ';

                    }

                    $sql .= $this->getSQLTableAlias($tableName, $dqlAlias) . '.' .

                            $qComp['metadata']->getQuotedColumnName($fieldName, $this->_platform) . " $orientation";

                }

            }

        }

        return $sql;

    }

    /**

     * Generates a discriminator column SQL condition for the class with the given DQL alias.

     *

     * @param array $dqlAliases List of root DQL aliases to inspect for discriminator restrictions.

     * @return string

     */

    private function _generateDiscriminatorColumnConditionSQL(array $dqlAliases)

    {

        $encapsulate = false;

        $sql = '';

        foreach ($dqlAliases as $dqlAlias) {

            $class = $this->_queryComponents[$dqlAlias]['metadata'];

            if ($class->isInheritanceTypeSingleTable()) {

                $conn = $this->_em->getConnection();

                $values = array();

                if ($class->discriminatorValue !== null) { // discrimnators can be 0

                    $values[] = $conn->quote($class->discriminatorValue);

                }

                foreach ($class->subClasses as $subclassName) {

                    $values[] = $conn->quote($this->_em->getClassMetadata($subclassName)->discriminatorValue);

                }

                if ($sql != '') {

                    $sql .= ' AND ';

                    $encapsulate = true;

                }

                $sql .= ($sql != '' ? ' AND ' : '')

                      . (($this->_useSqlTableAliases) ? $this->getSQLTableAlias($class->table['name'], $dqlAlias) . '.' : '')

                      . $class->discriminatorColumn['name'] . ' IN (' . implode(', ', $values) . ')';

            }

        }

        return ($encapsulate) ? '(' . $sql . ')' : $sql;

    }

    /**

     * Walks down a SelectStatement AST node, thereby generating the appropriate SQL.

     *

     * @return string The SQL.

     */

    public function walkSelectStatement(AST\SelectStatement $AST)

    {

        $sql = $this->walkSelectClause($AST->selectClause);

        $sql .= $this->walkFromClause($AST->fromClause);

        if (($whereClause = $AST->whereClause) !== null) {

            $sql .= $this->walkWhereClause($whereClause);

        } else if (($discSql = $this->_generateDiscriminatorColumnConditionSQL($this->_rootAliases)) !== '') {

            $sql .= ' WHERE ' . $discSql;

        }

        $sql .= $AST->groupByClause ? $this->walkGroupByClause($AST->groupByClause) : '';

        $sql .= $AST->havingClause ? $this->walkHavingClause($AST->havingClause) : '';

        if (($orderByClause = $AST->orderByClause) !== null) {

            $sql .= $AST->orderByClause ? $this->walkOrderByClause($AST->orderByClause) : '';

        } else if (($orderBySql = $this->_generateOrderedCollectionOrderByItems()) !== '') {

            $sql .= ' ORDER BY '.$orderBySql;

        }

        $sql = $this->_platform->modifyLimitQuery(

            $sql, $this->_query->getMaxResults(), $this->_query->getFirstResult()

        );

        if (($lockMode = $this->_query->getHint(Query::HINT_LOCK_MODE)) !== false) {

            if ($lockMode == LockMode::PESSIMISTIC_READ) {

                $sql .= " " . $this->_platform->getReadLockSQL();

            } else if ($lockMode == LockMode::PESSIMISTIC_WRITE) {

                $sql .= " " . $this->_platform->getWriteLockSQL();

            } else if ($lockMode == LockMode::OPTIMISTIC) {

                foreach ($this->_selectedClasses AS $class) {

                    if ( ! $class->isVersioned) {

                        throw \Doctrine\ORM\OptimisticLockException::lockFailed();

                    }

                }

            }

        }

        return $sql;

    }

    /**

     * Walks down an UpdateStatement AST node, thereby generating the appropriate SQL.

     *

     * @param UpdateStatement

     * @return string The SQL.

     */

    public function walkUpdateStatement(AST\UpdateStatement $AST)

    {

        $this->_useSqlTableAliases = false;

        $sql = $this->walkUpdateClause($AST->updateClause);

        if (($whereClause = $AST->whereClause) !== null) {

            $sql .= $this->walkWhereClause($whereClause);

        } else if (($discSql = $this->_generateDiscriminatorColumnConditionSQL($this->_rootAliases)) !== '') {

            $sql .= ' WHERE ' . $discSql;

        }

        return $sql;

    }

    /**

     * Walks down a DeleteStatement AST node, thereby generating the appropriate SQL.

     *

     * @param DeleteStatement

     * @return string The SQL.

     */