<?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;

use Doctrine\ORM\Query\Expr;

/**

 * This class is responsible for building DQL query strings via an object oriented

 * PHP interface.

 *

 * @since 2.0

 * @author Guilherme Blanco <guilhermeblanco@hotmail.com>

 * @author Jonathan Wage <jonwage@gmail.com>

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

 */

class QueryBuilder

{

    /* The query types. */

    const SELECT = 0;

    const DELETE = 1;

    const UPDATE = 2;

    /** The builder states. */

    const STATE_DIRTY = 0;

    const STATE_CLEAN = 1;

    /**

     * @var EntityManager The EntityManager used by this QueryBuilder.

     */

    private $_em;

    /**

     * @var array The array of DQL parts collected.

     */

    private $_dqlParts = array(

        'select'  => array(),

        'from'    => array(),

        'join'    => array(),

        'set'     => array(),

        'where'   => null,

        'groupBy' => array(),

        'having'  => null,

        'orderBy' => array()

    );

    /**

     * @var integer The type of query this is. Can be select, update or delete.

     */

    private $_type = self::SELECT;

    /**

     * @var integer The state of the query object. Can be dirty or clean.

     */

    private $_state = self::STATE_CLEAN;

    /**

     * @var string The complete DQL string for this query.

     */

    private $_dql;

    /**

     * @var array The query parameters.

     */

    private $_params = array();

    /**

     * @var array The parameter type map of this query.

     */

    private $_paramTypes = array();

    /**

     * @var integer The index of the first result to retrieve.

     */

    private $_firstResult = null;

    /**

     * @var integer The maximum number of results to retrieve.

     */

    private $_maxResults = null;

    /**

     * Initializes a new <tt>QueryBuilder</tt> that uses the given <tt>EntityManager</tt>.

     * 

     * @param EntityManager $em The EntityManager to use.

     */

    public function __construct(EntityManager $em)

    {

        $this->_em = $em;

    }

    /**

     * Gets an ExpressionBuilder used for object-oriented construction of query expressions.

     * This producer method is intended for convenient inline usage. Example:

     *

     * <code>

     *     $qb = $em->createQueryBuilder()

     *         ->select('u')

     *         ->from('User', 'u')

     *         ->where($qb->expr()->eq('u.id', 1));

     * </code>

     *

     * For more complex expression construction, consider storing the expression

     * builder object in a local variable.

     *

     * @return Expr

     */

    public function expr()

    {

        return $this->_em->getExpressionBuilder();

    }

    /**

     * Get the type of the currently built query.

     *

     * @return integer

     */

    public function getType()

    {

        return $this->_type;

    }

    /**

     * Get the associated EntityManager for this query builder.

     *

     * @return EntityManager

     */

    public function getEntityManager()

    {

        return $this->_em;

    }

    /**

     * Get the state of this query builder instance.

     *

     * @return integer Either QueryBuilder::STATE_DIRTY or QueryBuilder::STATE_CLEAN.

     */

    public function getState()

    {

        return $this->_state;

    }

    /**

     * Get the complete DQL string formed by the current specifications of this QueryBuilder.

     *

     * <code>

     *     $qb = $em->createQueryBuilder()

     *         ->select('u')

     *         ->from('User', 'u')

     *     echo $qb->getDql(); // SELECT u FROM User u

     * </code>

     *

     * @return string The DQL query string.

     */

    public function getDQL()

    {

        if ($this->_dql !== null && $this->_state === self::STATE_CLEAN) {

            return $this->_dql;

        }

        $dql = '';

        switch ($this->_type) {

            case self::DELETE:

                $dql = $this->_getDQLForDelete();

                break;

            case self::UPDATE:

                $dql = $this->_getDQLForUpdate();

                break;

            case self::SELECT:

            default:

                $dql = $this->_getDQLForSelect();

                break;

        }

        $this->_state = self::STATE_CLEAN;

        $this->_dql = $dql;

        return $dql;

    }

    /**

     * Constructs a Query instance from the current specifications of the builder.

     *

     * <code>

     *     $qb = $em->createQueryBuilder()

     *         ->select('u')

     *         ->from('User', 'u');

     *     $q = $qb->getQuery();

     *     $results = $q->execute();

     * </code>

     *

     * @return Query

     */

    public function getQuery()

    {

        return $this->_em->createQuery($this->getDQL())

                ->setParameters($this->_params, $this->_paramTypes)

                ->setFirstResult($this->_firstResult)

                ->setMaxResults($this->_maxResults);

    }

    /**

     * Gets the FIRST root alias of the query. This is the first entity alias involved

     * in the construction of the query.

     *

     * <code>

     * $qb = $em->createQueryBuilder()

     * ->select('u')

     * ->from('User', 'u');

     *

     * echo $qb->getRootAlias(); // u

     * </code>

     *

     * @deprecated Please use $qb->getRootAliases() instead.

     * @return string $rootAlias

     */

    public function getRootAlias()

    {

        $aliases = $this->getRootAliases();

        return $aliases[0];

    }

    /**

     * Gets the root aliases of the query. This is the entity aliases involved

     * in the construction of the query.

     *

     * <code>

     *     $qb = $em->createQueryBuilder()

     *         ->select('u')

     *         ->from('User', 'u');

     *

     *     $qb->getRootAliases(); // array('u')

     * </code>

     *

     * @return array $rootAliases

     */

    public function getRootAliases()

    {

        $aliases = array();

        foreach ($this->_dqlParts['from'] as &$fromClause) {

            if (is_string($fromClause)) {

                $spacePos = strrpos($fromClause, ' ');

                $from     = substr($fromClause, 0, $spacePos);

                $alias    = substr($fromClause, $spacePos + 1);

                $fromClause = new Query\Expr\From($from, $alias);

            }

            $aliases[] = $fromClause->getAlias();

        }

        return $aliases;

    }

    /**

     * Gets the root entities of the query. This is the entity aliases involved

     * in the construction of the query.

     *

     * <code>

     *     $qb = $em->createQueryBuilder()

     *         ->select('u')

     *         ->from('User', 'u');

     *

     *     $qb->getRootEntities(); // array('User')

     * </code>

     *

     * @return array $rootEntities

     */

    public function getRootEntities()

    {

        $entities = array();

        foreach ($this->_dqlParts['from'] as &$fromClause) {

            if (is_string($fromClause)) {

                $spacePos = strrpos($fromClause, ' ');

                $from     = substr($fromClause, 0, $spacePos);

                $alias    = substr($fromClause, $spacePos + 1);

                $fromClause = new Query\Expr\From($from, $alias);

            }

            $entities[] = $fromClause->getFrom();

        }

        return $entities;

    }

    /**

     * Sets a query parameter for the query being constructed.

     *

     * <code>

     *     $qb = $em->createQueryBuilder()

     *         ->select('u')

     *         ->from('User', 'u')

     *         ->where('u.id = :user_id')

     *         ->setParameter(':user_id', 1);

     * </code>

     *

     * @param string|integer $key The parameter position or name.

     * @param mixed $value The parameter value.

     * @param string|null $type PDO::PARAM_* or \Doctrine\DBAL\Types\Type::* constant

     * @return QueryBuilder This QueryBuilder instance.

     */

    public function setParameter($key, $value, $type = null)

    {

        if ($type === null) {

            $type = Query\ParameterTypeInferer::inferType($value);

        }

        $this->_paramTypes[$key] = $type;

        $this->_params[$key] = $value;

        return $this;

    }

    /**

     * Sets a collection of query parameters for the query being constructed.

     *

     * <code>

     *     $qb = $em->createQueryBuilder()

     *         ->select('u')

     *         ->from('User', 'u')

     *         ->where('u.id = :user_id1 OR u.id = :user_id2')

     *         ->setParameters(array(

     *             ':user_id1' => 1,

     *             ':user_id2' => 2

     *         ));

     * </code>

     *

     * @param array $params The query parameters to set.

     * @return QueryBuilder This QueryBuilder instance.

     */

    public function setParameters(array $params, array $types = array())

    {

        foreach ($params as $key => $value) {

            if (isset($types[$key])) {

                $this->setParameter($key, $value, $types[$key]);

            } else {

                $this->setParameter($key, $value);

            }

        }

        return $this;

    }

    /**

     * Gets all defined query parameters for the query being constructed.

     *

     * @return array The currently defined query parameters.

     */

    public function getParameters()

    {

        return $this->_params;

    }

    /**

     * Gets a (previously set) query parameter of the query being constructed.

     * 

     * @param mixed $key The key (index or name) of the bound parameter.

     * @return mixed The value of the bound parameter.

     */

    public function getParameter($key)

    {

        return isset($this->_params[$key]) ? $this->_params[$key] : null;

    }

    /**

     * Sets the position of the first result to retrieve (the "offset").

     *

     * @param integer $firstResult The first result to return.

     * @return QueryBuilder This QueryBuilder instance.

     */

    public function setFirstResult($firstResult)

    {

        $this->_firstResult = $firstResult;

        return $this;

    }

    /**

     * Gets the position of the first result the query object was set to retrieve (the "offset").

     * Returns NULL if {@link setFirstResult} was not applied to this QueryBuilder.

     * 

     * @return integer The position of the first result.

     */

    public function getFirstResult()

    {

        return $this->_firstResult;

    }

    /**

     * Sets the maximum number of results to retrieve (the "limit").

     * 

     * @param integer $maxResults The maximum number of results to retrieve.

     * @return QueryBuilder This QueryBuilder instance.

     */

    public function setMaxResults($maxResults)

    {

        $this->_maxResults = $maxResults;

        return $this;

    }

    /**

     * Gets the maximum number of results the query object was set to retrieve (the "limit").

     * Returns NULL if {@link setMaxResults} was not applied to this query builder.

     * 

     * @return integer Maximum number of results.

     */

    public function getMaxResults()

    {

        return $this->_maxResults;

    }

    /**

     * Either appends to or replaces a single, generic query part.

     *

     * The available parts are: 'select', 'from', 'join', 'set', 'where',

     * 'groupBy', 'having' and 'orderBy'.

     *

     * @param string $dqlPartName 

     * @param string $dqlPart 

     * @param string $append 

     * @return QueryBuilder This QueryBuilder instance.

     */

    public function add($dqlPartName, $dqlPart, $append = false)

    {

        $isMultiple = is_array($this->_dqlParts[$dqlPartName]);

        // This is introduced for backwards compatibility reasons.

        // TODO: Remove for 3.0

        if ($dqlPartName == 'join') {

            $newDqlPart = array();

            foreach ($dqlPart AS $k => $v) {

                if (is_numeric($k)) {

                    $newDqlPart[$this->getRootAlias()] = $v;

                } else {

                    $newDqlPart[$k] = $v;

                }

            }

            $dqlPart = $newDqlPart;

        }

        if ($append && $isMultiple) {