Second part of commit, including the Doctrine/ORM/Query namespace.

lib/Doctrine/ORM/Query/AST.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * Abstract class of an AST node
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+abstract class Doctrine_ORM_Query_AST
+{
+    protected $_parserResult = null;
+    
+    
+    public function __construct(Doctrine_ORM_Query_ParserResult $parserResult)
+    {
+        $this->_parserResult = $parserResult;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/AbstractSchemaName.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * AbstractSchemaName ::= identifier
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_AbstractSchemaName extends Doctrine_ORM_Query_AST
+{
+    protected $_componentName;
+    
+    
+    /* Setters */
+    public function setComponentName($componentName)
+    {
+        $this->_componentName = $componentName;
+    }
+    
+    
+    /* Getters */
+    public function getComponentName()
+    {
+        return $this->_componentName;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/AliasIdentificationVariable.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * AliasIdentificationVariable ::= identifier
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_AliasIdentificationVariable extends Doctrine_ORM_Query_AST
+{
+    protected $_componentAlias;
+    
+    
+    /* Setters */
+    public function setComponentAlias($componentAlias)
+    {
+        $this->_componentAlias = $componentAlias;
+    }
+    
+    
+    /* Getters */
+    public function getComponentAlias()
+    {
+        return $this->_componentAlias;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/DeleteStatement.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * DeleteStatement = DeleteClause [WhereClause]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_DeleteStatement extends Doctrine_ORM_Query_AST
+{
+    protected $_deleteClause;
+
+    protected $_whereClause;
+    
+    
+    /* Setters */
+    public function setDeleteClause($deleteClause)
+    {
+        $this->_deleteClause = $deleteClause;
+    }
+
+    
+    public function setWhereClause($whereClause)
+    {
+        $this->_whereClause = $whereClause;
+    }
+    
+    
+    /* Getters */
+    public function getDeleteClause()
+    {
+        return $this->_deleteClause;
+    }
+
+    
+    public function getWhereClause()
+    {
+        return $this->_whereClause;
+    }
+    
+    
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        // The 1=1 is needed to workaround the affected_rows in MySQL.
+        // Simple "DELETE FROM table_name" gives 0 affected rows.
+        return $this->_deleteClause->buildSql() . (($this->_whereClause !== null)
+             ? ' ' . $this->_whereClause->buildSql() : ' WHERE 1 = 1');
+    }
+}    
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/FieldIdentificationVariable.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * FieldIdentificationVariable ::= identifier
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_FieldIdentificationVariable extends Doctrine_ORM_Query_AST
+{
+    protected $_fieldName;
+
+
+    /* Setters */
+    public function setFieldName($fieldName)
+    {
+        $this->_fieldName = $fieldName;
+    }
+
+    
+    /* Getters */
+    public function getFieldName()
+    {
+        return $this->_fieldName;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/FromClause.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_FromClause extends Doctrine_ORM_Query_AST
+{
+    protected $_identificationVariableDeclarations = array();
+    
+
+    /* Setters */
+    public function addIdentificationVariableDeclaration($identificationVariableDeclaration)
+    {
+        $this->_identificationVariableDeclarations[] = $identificationVariableDeclaration;
+    }
+
+
+    public function setIdentificationVariableDeclarations($identificationVariableDeclarations, $append = false)
+    {
+        $this->_selectExpressions = ($append === true)
+            ? array_merge($this->_identificationVariableDeclarations, $identificationVariableDeclarations)
+            : $identificationVariableDeclarations;
+    }
+    
+    
+    /* Getters */
+    public function getIdentificationVariableDeclarations()
+    {
+        return $this->_identificationVariableDeclarations;
+    }
+    
+    
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        //echo "FromClause:\n";
+        //for ($i = 0; $i < count($this->_identificationVariableDeclaration);$i++) {
+        //    echo (($this->_identificationVariableDeclaration[$i] instanceof IdentificationVariableDeclaration) 
+        //        ? get_class($this->_identificationVariableDeclaration[$i]) 
+        //        : get_class($this->_identificationVariableDeclaration[$i])) . "\n";
+        //}
+
+        return 'FROM ' . implode(', ', $this->_mapIdentificationVariableDeclarations());
+    }
+
+
+    protected function _mapIdentificationVariableDeclarations()
+    {
+        return array_map(
+            array(&$this, '_mapIdentificationVariableDeclaration'), $this->_identificationVariableDeclarations
+        );
+    }
+
+
+    protected function _mapIdentificationVariableDeclaration($value)
+    {
+        return $value->buildSql();
+    }
+}

lib/Doctrine/ORM/Query/AST/IdentificationVariable.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * IdentificationVariable ::= identifier
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_IdentificationVariable extends Doctrine_ORM_Query_AST
+{
+    protected $_componentAlias;
+    
+    
+    /* Setters */
+    public function setComponentAlias($componentAlias)
+    {
+        $this->_componentAlias = $componentAlias;
+    }
+    
+    
+    /* Getters */
+    public function getComponentAlias()
+    {
+        return $this->_componentAlias;
+    }
+    
+    
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        $conn = $this->_parserResult->getEntityManager()->getConnection();
+
+        return $conn->quoteIdentifier(
+            $this->_parserResult->getTableAliasFromComponentAlias($this->_componentAlias)
+        );
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/IdentificationVariableDeclaration.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}*
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_IdentificationVariableDeclaration extends Doctrine_ORM_Query_AST
+{
+    protected $_rangeVariableDeclaration = null;
+    
+    protected $_indexBy = null;
+
+    protected $_joinVariableDeclarations = array();
+    
+
+    /* Setters */
+    public function setRangeVariableDeclaration($rangeVariableDeclaration)
+    {
+        $this->_rangeVariableDeclaration = $rangeVariableDeclaration;
+    }
+
+
+    public function setIndexBy($indexBy)
+    {
+        $this->_indexBy = $indexBy;
+    }
+
+
+    public function addJoinVariableDeclaration($joinVariableDeclaration)
+    {
+        $this->_joinVariableDeclarations[] = $joinVariableDeclaration;
+    }
+
+
+    public function setJoinVariableDeclarations($joinVariableDeclarations, $append = false)
+    {
+        $this->_joinVariableDeclarations = ($append === true)
+            ? array_merge($this->_joinVariableDeclarations, $joinVariableDeclarations)
+            : $joinVariableDeclarations;
+    }
+
+    
+    /* Getters */
+    public function getRangeVariableDeclaration()
+    {
+        return $this->_rangeVariableDeclaration;
+    }
+
+
+    public function getIndexBy()
+    {
+        return $this->_indexBy;
+    }
+    
+
+    public function getJoinVariableDeclarations()
+    {
+        return $this->_joinVariableDeclarations;
+    }
+
+
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        $str = $this->_rangeVariableDeclaration->buildSql();
+
+        for ($i = 0, $l = count($this->_joinVariableDeclarations); $i < $l; $i++) {
+            $str .= ' ' . $this->_joinVariableDeclarations[$i]->buildSql();
+        }
+
+        return $str;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/IndexBy.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * IndexBy ::= "INDEX" "BY" SimpleStateFieldPathExpression
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_IndexBy extends Doctrine_ORM_Query_AST
+{
+    protected $_simpleStateFieldPathExpression = null;
+    
+    
+    /* Setters */
+    public function setSimpleStateFieldPathExpression($simpleStateFieldPathExpression)
+    {
+        $this->_simpleStateFieldPathExpression = $simpleStateFieldPathExpression;
+    }
+    
+    
+    /* Getters */
+    public function getSimpleStateFieldPathExpression()
+    {
+        return $this->_simpleStateFieldPathExpression;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/Join.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression
+ *          ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_Join extends Doctrine_ORM_Query_AST
+{
+    const JOIN_TYPE_LEFT = 1;
+
+    const JOIN_TYPE_LEFTOUTER = 2;
+
+    const JOIN_TYPE_INNER = 3;
+
+
+    const JOIN_WHERE_ON = 1;
+
+    const JOIN_WHERE_WITH = 2;
+
+
+    protected $_joinType = self::JOIN_TYPE_INNER;
+    
+    protected $_joinAssociationPathExpression = null;
+    
+    protected $_aliasIdentificationVariable = null;
+
+    protected $_whereType = self::JOIN_WHERE_WITH;
+    
+    protected $_conditionalExpression = null;
+    
+    
+    /* Setters */
+    public function setJoinType($joinType)
+    {
+        $this->_joinType = $joinType;
+    }
+    
+    public function setJoinAssociationPathExpression($joinAssociationPathExpression)
+    {
+        $this->_joinAssociationPathExpression = $joinAssociationPathExpression;
+    }
+    
+    public function setAliasIdentificationVariable($aliasIdentificationVariable)
+    {
+        $this->_aliasIdentificationVariable = $aliasIdentificationVariable;
+    }
+    
+    public function setWhereType($whereType)
+    {
+        $this->_whereType = $whereType;
+    }
+    
+    public function setConditionalExpression($conditionalExpression)
+    {
+        $this->_conditionalExpression = $conditionalExpression;
+    }
+    
+    
+    /* Getters */
+    public function getJoinType()
+    {
+        return $this->_joinType;
+    }
+    
+    public function getJoinAssociationPathExpression()
+    {
+        return $this->_joinAssociationPathExpression;
+    }
+    
+    public function getAliasIdentificationVariable()
+    {
+        return $this->_aliasIdentificationVariable;
+    }
+    
+    public function getWhereType()
+    {
+        return $this->_whereType;
+    }
+    
+    public function getConditionalExpression()
+    {
+        return $this->_conditionalExpression;
+    }
+    
+    
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        $join = '';
+
+        switch ($this->_joinType) {
+            case self::JOIN_TYPE_LEFT:
+                $join .= 'LEFT';
+                break;
+                
+            case self::JOIN_TYPE_LEFTOUTER:
+                $join .= 'LEFT OUTER';
+                break;
+                
+            case self::JOIN_TYPE_INNER:
+            default:
+                $join .= 'INNER';
+                break;
+        }
+        
+        $join .= ' JOIN ' . $this->_joinAssociationPathExpression->buildSql();
+        $condition = isset($this->_conditionalExpression)
+            ? $this->_conditionalExpression->buildSql() : '';
+        
+        switch ($this->whereType) {
+            case self::JOIN_WHERE_ON:
+                // Nothing to do here... =)
+                break;
+                
+            case self::JOIN_WHERE_WITH:
+            default:
+            
+                /*
+
+                TODO: Refactor to support split!!!
+
+                $parserResult = $this->_parser->getParserResult();
+        
+                // Get the connection for the component
+                $conn = $this->_em->getConnection();
+
+                // We need to build the join conditions. Retrieving AssociationMapping
+                $queryComponent = $this->_rangeVariableDeclaration->getQueryComponent();
+                $association = $queryComponent['relation'];
+                $joinColumns = array();
+                
+                if ($association->isOneToMany() || $association->isOneToOne()) {
+                    if ($association->isInverseSide()) {
+                        // joinColumns are found on the other (owning) side
+                        $targetClass = $this->_em->getClassMetadata($association->getTargetEntityName());
+                        $joinColumns = $targetClass->getAssociationMapping($association->getMappedByFieldName())
+                                ->getTargetToSourceKeyColumns();
+                    } else {
+                        $joinColumns = $association->getSourceToTargetKeyColumns();
+                    }
+                } else {
+                    //TODO: many-many
+                }
+               
+                $relationConditionExpression = '';
+        
+                // We have an array('localColumn' => 'foreignColumn', ...) here
+                foreach ($joinColumns as $localColumn => $foreignColumn) {
+                    // leftExpression = rightExpression
+        
+                    // Defining leftExpression
+                    $leftExpression = $conn->quoteIdentifier(
+                        $parserResult->getTableAliasFromComponentAlias($queryComponent['parent']) . '.' . $localColumn
+                    );
+        
+                    // Defining rightExpression
+                    $rightExpression = $conn->quoteIdentifier(
+                        $parserResult->getTableAliasFromComponentAlias(
+                            $this->_rangeVariableDeclaration->getIdentificationVariable()
+                        ) . '.' . $foreignColumn
+                     );
+        
+                     // Building the relation
+                     $relationConditionExpression .= (($relationConditionExpression != '') ? ' AND ' : '')
+                         . $leftExpression . ' = ' . $rightExpression;
+                }
+                
+                $sql .= ' ON ' . $relationConditionExpression;
+                $sql .= empty($conditionExpression) ? '' : ' AND (' . $conditionExpression . ')';
+                */
+
+                break;
+        }
+        
+        return $join . ' ON ' . $condition;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/JoinVariableDeclaration.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * JoinVariableDeclaration ::= Join [IndexBy]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_JoinVariableDeclaration extends Doctrine_ORM_Query_AST
+{
+    protected $_join = null;
+    
+    protected $_indexBy = null;
+
+
+    /* Setters */
+    public function setJoin($join)
+    {
+        $this->_join = $join;
+    }
+
+
+    public function setIndexBy($indexBy)
+    {
+        $this->_indexBy = $indexBy;
+    }
+
+    
+    /* Getters */
+    public function getJoin()
+    {
+        return $this->_join;
+    }
+
+
+    public function getIndexBy()
+    {
+        return $this->_indexBy;
+    }
+
+
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        return $this->_join->buildSql() . (isset($this->_indexby) ? $this->_indexby->buildSql() . ' ' : '');
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/RangeVariableDeclaration.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_RangeVariableDeclaration extends Doctrine_ORM_Query_AST
+{
+    protected $_abstractSchemaName = null;
+    
+    protected $_aliasIdentificationVariable = null;
+    
+    
+    /* Setters */
+    public function setAbstractSchemaName($abstractSchemaName)
+    {
+        $this->_abstractSchemaName = $abstractSchemaName;
+    }
+
+
+    public function setAliasIdentificationVariable($aliasIdentificationVariable)
+    {
+        $this->_aliasIdentificationVariable = $aliasIdentificationVariable;
+    }
+    
+    
+    /* Getters */
+    public function getAbstractSchemaName()
+    {
+        return $this->_abstractSchemaName;
+    }
+
+
+    public function getAliasIdentificationVariable()
+    {
+        return $this->_aliasIdentificationVariable;
+    }
+    
+    
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        // Retrieving connection
+        $conn = $this->_parserResult->getEntityManager()->getConnection();
+        
+        // Component alias
+        $componentAlias = $this->_aliasIdentificationVariable->getComponentAlias();
+
+        // Retrieving required information
+        try {
+            $queryComponent = $this->_parserResult->getQueryComponent($componentAlias);
+            $classMetadata = $queryComponent['metadata'];
+        } catch (Doctrine_Exception $e) {
+            $this->_parser->semanticalError($e->getMessage());
+
+            return;
+        }
+
+        return $conn->quoteIdentifier($classMetadata->getTableName()) . ' '
+             . $conn->quoteIdentifier($this->_parserResult->getTableAliasFromComponentAlias($componentAlias));
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/SelectClause.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * SelectClause = "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_SelectClause extends Doctrine_ORM_Query_AST
+{
+    protected $_isDistinct;
+
+    protected $_selectExpressions = array();
+    
+    
+    /* Setters */
+    public function setIsDistinct($value)
+    {
+        $this->_isDistinct = $value;
+    }
+    
+    
+    public function addSelectExpression($expression)
+    {
+        $this->_selectExpressions[] = $expression;
+    }
+
+
+    public function setSelectExpressions($expressions, $append = false)
+    {
+        $this->_selectExpressions = ($append === true)
+            ? array_merge($this->_selectExpressions, $expressions)
+            : $expressions;
+    }
+
+    
+    /* Getters */
+    public function isDistinct()
+    {
+        return $this->_isDistinct;
+    }
+
+
+    public function getSelectExpressions()
+    {
+        return $this->_selectExpressions;
+    }
+    
+    
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        return 'SELECT ' . (($this->_isDistinct) ? 'DISTINCT ' : '')
+             . implode(', ', $this->_mapSelectExpressions());
+    }
+
+
+    protected function _mapSelectExpressions()
+    {
+        return array_map(array(&$this, '_mapSelectExpression'), $this->_selectExpressions);
+    }
+
+
+    protected function _mapSelectExpression($value)
+    {
+        return $value->buildSql();
+    }
+}

lib/Doctrine/ORM/Query/AST/SelectStatement.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * SelectStatement = SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_SelectStatement extends Doctrine_ORM_Query_AST
+{
+    protected $_selectClause;
+
+    protected $_fromClause;
+
+    protected $_whereClause;
+
+    protected $_groupByClause;
+
+    protected $_havingClause;
+
+    protected $_orderByClause;
+    
+    
+    /* Setters */
+    public function setSelectClause($selectClause)
+    {
+        $this->_selectClause = $selectClause;
+    }
+
+
+    public function setFromClause($fromClause)
+    {
+        $this->_fromClause = $fromClause;
+    }
+
+
+    public function setWhereClause($whereClause)
+    {
+        $this->_whereClause = $whereClause;
+    }
+
+
+    public function setGroupByClause($groupByClause)
+    {
+        $this->_groupByClause = $groupByClause;
+    }
+
+
+    public function setHavingClause($havingClause)
+    {
+        $this->_havingClause = $havingClause;
+    }
+
+
+    public function setOrderByClause($orderByClause)
+    {
+        $this->_orderByClause = $orderByClause;
+    }
+    
+    
+    /* Getters */
+    public function getSelectClause()
+    {
+        return $this->_selectClause;
+    }
+
+
+    public function getFromClause()
+    {
+        return $this->_fromClause;
+    }
+
+
+    public function getWhereClause()
+    {
+        return $this->_whereClause;
+    }
+
+
+    public function getGroupByClause()
+    {
+        return $this->_groupByClause;
+    }
+
+
+    public function getHavingClause()
+    {
+        return $this->_havingClause;
+    }
+
+
+    public function getOrderByClause()
+    {
+        return $this->_orderByClause;
+    }
+    
+    
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        return $this->_selectClause->buildSql() . ' ' . $this->_fromClause->buildSql()
+             . (($this->_whereClause !== null) ? ' ' . $this->_whereClause->buildSql() : ' WHERE 1 = 1')
+             . (($this->_groupByClause !== null) ? ' ' . $this->_groupByClause->buildSql() : '')
+             . (($this->_havingClause !== null) ? ' ' . $this->_havingClause->buildSql() : '')
+             . (($this->_orderByClause !== null) ? ' ' . $this->_orderByClause->buildSql() : '');
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/SimpleStateFieldPathExpression.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * SimpleStateFieldPathExpression ::= IdentificationVariable "." SimpleStateField
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_SimpleStateFieldPathExpression extends Doctrine_ORM_Query_AST
+{
+    protected $_identificationVariable = null;
+
+    protected $_simpleStateField = null;
+    
+    
+    /* Setters */
+    public function setIdentificationVariable($identificationVariable)
+    {
+        $this->_identificationVariable = $identificationVariable;
+    }
+
+
+    public function setSimpleStateField($simpleStateField)
+    {
+        $this->_simpleStateField = $simpleStateField;
+    }
+    
+    
+    /* Getters */
+    public function getIdentificationVariable()
+    {
+        return $this->_identificationVariable;
+    }
+
+
+    public function getSimpleStateField()
+    {
+        return $this->_simpleStateField;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/AST/UpdateStatetement.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * UpdateStatement = UpdateClause [WhereClause]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_AST_UpdateStatement extends Doctrine_ORM_Query_AST
+{
+    protected $_updateClause;
+
+    protected $_whereClause;
+    
+    
+    /* Setters */
+    public function setUpdateClause($updateClause)
+    {
+        $this->_updateClause = $updateClause;
+    }
+
+    
+    public function setWhereClause($whereClause)
+    {
+        $this->_whereClause = $whereClause;
+    }
+
+    
+    /* Getters */
+    public function getUpdateClause()
+    {
+        return $this->_updateClause;
+    }
+
+    
+    public function getWhereClause()
+    {
+        return $this->_whereClause;
+    }
+    
+    
+    /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
+    
+    public function buildSql()
+    {
+        // The 1=1 is needed to workaround the affected_rows in MySQL.
+        // Simple "UPDATE table_name SET column_name = value" gives 0 affected rows.
+        return $this->_updateClause->buildSql() . (($this->_whereClause !== null)
+             ? ' ' . $this->_whereClause->buildSql() : ' WHERE 1 = 1');
+    }
+}    
\ No newline at end of file

lib/Doctrine/ORM/Query/AbstractResult.php

+<?php
+
+/*
+ *  $Id: Cache.php 3938 2008-03-06 19:36:50Z romanb $
+ *
+ * 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.phpdoctrine.org>.
+ */
+
+/**
+ * Doctrine_ORM_Query_AbstractResult
+ *
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        www.phpdoctrine.com
+ * @since       2.0
+ * @version     $Revision: 1393 $
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Konsta Vesterinen <kvesteri@cc.hut.fi>
+ */
+abstract class Doctrine_ORM_Query_AbstractResult
+{
+    /**
+     * @var mixed $_data The actual data to be stored. Can be an array, a string or an integer.
+     */
+    protected $_data;
+
+    /**
+     * @var array $_queryComponents
+     *
+     * Two dimensional array containing the map for query aliases. Main keys are component aliases.
+     *
+     * table    Table object associated with given alias.
+     * relation Relation object owned by the parent.
+     * parent   Alias of the parent.
+     * agg      Aggregates of this component.
+     * map      Name of the column / aggregate value this component is mapped to a collection.
+     */
+    protected $_queryComponents;
+
+    /**
+     * @var array Table alias map. Keys are SQL aliases and values DQL aliases.
+     */
+    protected $_tableAliasMap;
+
+    /**
+     * @var array Enum params.
+     */
+    protected $_enumParams;
+
+
+    /**
+     * Cannot be called directly, factory methods handle this job.
+     *
+     * @param mixed $data Data to be stored.
+     * @param array $queryComponents Query components.
+     * @param array $tableAliasMap Table aliases.
+     * @param array $enumParams Enum params.
+     * @return Doctrine_ORM_Query_CacheHandler
+     */
+    public function __construct($data = '', $queryComponents = array(), $tableAliasMap = array(), $enumParams = array())
+    {
+        $this->_data = $data;
+        $this->_queryComponents = $queryComponents;
+        $this->_tableAliasMap = $tableAliasMap;
+        $this->_enumParams = $enumParams;
+    }
+
+
+    /**
+     * Defines the mapping components.
+     *
+     * @param array $queryComponents Query components.
+     */
+    public function setQueryComponents(array $queryComponents)
+    {
+        $this->_queryComponents = $queryComponents;
+    }
+
+
+    /**
+     * Sets the declaration for given component alias.
+     *
+     * @param string $componentAlias The component alias to set the declaration to.
+     * @param string $queryComponent Alias declaration.
+     */
+    public function setQueryComponent($componentAlias, array $queryComponent)
+    {
+        $this->_queryComponents[$componentAlias] = $queryComponent;
+    }
+
+
+    /**
+     * Gets the mapping components.
+     *
+     * @return array Query components.
+     */
+    public function getQueryComponents()
+    {
+        return $this->_queryComponents;
+    }
+
+
+    /**
+     * Get the declaration for given component alias.
+     *
+     * @param string $componentAlias The component alias the retrieve the declaration from.
+     * @return array Alias declaration.
+     */
+    public function getQueryComponent($componentAlias)
+    {
+        if ( ! array_key_exists($componentAlias, $this->_queryComponents)) {
+            throw new Doctrine_ORM_Query_Exception('Unknown query component ' . $componentAlias);
+        }
+
+        return $this->_queryComponents[$componentAlias];
+    }
+
+
+    /**
+     * Get the component alias for a given query component
+     *
+     * @param array $queryComponent The query component
+     * @param string Component alias
+     */
+    public function getComponentAlias($queryComponent)
+    {
+        return array_search($queryComponent, $this->_queryComponents);;
+    }
+
+
+    /**
+     * Whether or not this object has a declaration for given component alias.
+     *
+     * @param string $componentAlias Component alias the retrieve the declaration from.
+     * @return boolean True if this object has given alias, otherwise false.
+     */
+    public function hasQueryComponent($componentAlias)
+    {
+        return isset($this->_queryComponents[$componentAlias]);
+    }
+
+
+    /**
+     * Defines the table aliases.
+     *
+     * @param array $tableAliasMap Table aliases.
+     */
+    public function setTableAliasMap(array $tableAliasMap)
+    {
+        $this->_tableAliasMap = $tableAliasMap;
+    }
+
+
+    /**
+     * Adds an SQL table alias and associates it a component alias
+     *
+     * @param string $tableAlias Table alias to be added.
+     * @param string $componentAlias Alias for the query component associated with given tableAlias.
+     */
+    public function setTableAlias($tableAlias, $componentAlias)
+    {
+        $this->_tableAliasMap[$tableAlias] = $componentAlias;
+    }
+
+
+    /**
+     * Returns all table aliases.
+     *
+     * @return array Table aliases as an array.
+     */
+    public function getTableAliasMap()
+    {
+        return $this->_tableAliasMap;
+    }
+
+
+    /**
+     * Get component alias associated with given table alias.
+     *
+     * @param string $tableAlias SQL table alias that identifies the component alias
+     * @return string Component alias
+     */
+    public function getTableAlias($tableAlias)
+    {
+        if ( ! isset($this->_tableAliasMap[$tableAlias])) {
+            throw new Doctrine_ORM_Query_Exception('Unknown table alias ' . $tableAlias);
+        }
+
+        return $this->_tableAliasMap[$tableAlias];
+    }
+
+
+    /**
+     * Get table alias associated with given component alias.
+     *
+     * @param string $componentAlias Component alias that identifies the table alias
+     * @return string Component alias
+     */
+    public function getTableAliasFromComponentAlias($componentAlias)
+    {
+        return array_search($componentAlias, $this->_tableAliasMap);
+    }
+
+
+    /**
+     * Whether or not this object has given tableAlias.
+     *
+     * @param string $tableAlias Table alias to be checked.
+     * @return boolean True if this object has given alias, otherwise false.
+     */
+    public function hasTableAlias($tableAlias)
+    {
+        return (isset($this->_tableAliasMap[$tableAlias]));
+    }
+
+
+    /**
+     * Returns the enum parameters.
+     *
+     * @return mixed Enum parameters.
+     */
+    public function getEnumParams()
+    {
+        return $this->_enumParams;
+    }
+
+
+    /**
+     * Sets input parameter as an enumerated parameter
+     *
+     * @param string $key The key of the input parameter
+     * @return Doctrine_ORM_Query_AbstractResult
+     */
+    public function addEnumParam($key, $table = null, $column = null)
+    {
+        $array = (isset($table) || isset($column)) ? array($table, $column) : array();
+
+        if ($key === '?') {
+            $this->_enumParams[] = $array;
+        } else {
+            $this->_enumParams[$key] = $array;
+        }
+
+        return $this;
+    }
+
+
+    /**
+     * Returns this object in serialized format, revertable using fromCached*.
+     *
+     * @return string Serialized cached item.
+     */
+    public function toCachedForm()
+    {
+        return serialize(array(
+            $this->_data,
+            $this->getQueryComponents(),
+            $this->getTableAliasMap(),
+            $this->getEnumParams()
+        ));
+    }
+
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/CacheHandler.php

+<?php
+
+/*
+ *  $Id: Cache.php 3938 2008-03-06 19:36:50Z romanb $
+ *
+ * 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.phpdoctrine.org>.
+ */
+
+/**
+ * Doctrine_ORM_Query_CacheHandler
+ *
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        www.phpdoctrine.com
+ * @since       1.0
+ * @version     $Revision: 1393 $
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Konsta Vesterinen <kvesteri@cc.hut.fi>
+ *
+ * @todo Re-document this class
+ */
+abstract class Doctrine_ORM_Query_CacheHandler
+{
+    /**
+     * Static factory method. Receives a Doctrine_ORM_Query object and generates
+     * the object after processing queryComponents. Table aliases are retrieved
+     * directly from Doctrine_ORM_Query_Parser.
+     *
+     * @param mixed $result Data to be stored.
+     * @param Doctrine_ORM_Query_ParserResult $parserResult Parser results that enables to have important data retrieved.
+     */
+    public static function fromResultSet($result, $parserResult)
+    {
+        $queryComponents = array();
+
+        foreach ($parserResult->getQueryComponents() as $alias => $components) {
+            if ( ! isset($components['parent'])) {
+                $queryComponents[$alias][] = $components['mapper']->getComponentName();
+                //$queryComponents[$alias][] = $components['mapper']->getComponentName();
+            } else {
+                $queryComponents[$alias][] = $components['parent'] . '.' . $components['relation']->getAlias();
+            }
+
+            if (isset($components['agg'])) {
+                $queryComponents[$alias][] = $components['agg'];
+            }
+
+            if (isset($components['map'])) {
+                $queryComponents[$alias][] = $components['map'];
+            }
+        }
+
+        return new Doctrine_ORM_Query_QueryResult(
+            $result,
+            $queryComponents,
+            $parserResult->getTableAliasMap(),
+            $parserResult->getEnumParams()
+        );
+    }
+
+
+
+    /**
+     * Static factory method. Receives a Doctrine_ORM_Query object and a cached data.
+     * It handles the cache and generates the object after processing queryComponents.
+     * Table aliases are retrieved from cache.
+     *
+     * @param Doctrine_ORM_Query $query Doctrine_ORM_Query_Object related to this cache item.
+     * @param mixed $cached Cached data.
+     */
+    public static function fromCachedResult($query, $cached = false)
+    {
+        $cached = unserialize($cached);
+
+        return new Doctrine_ORM_Query_QueryResult(
+            $cached[0],
+            self::_getQueryComponents($cached[1]),
+            $cached[2],
+            $cached[3]
+        );
+    }
+
+
+    /**
+     * Static factory method. Receives a Doctrine_ORM_Query object and a cached data.
+     * It handles the cache and generates the object after processing queryComponents.
+     * Table aliases are retrieved from cache.
+     *
+     * @param Doctrine_ORM_Query $query Doctrine_ORM_Query_Object related to this cache item.
+     * @param mixed $cached Cached data.
+     */
+    public static function fromCachedQuery($query, $cached = false)
+    {
+        $cached = unserialize($cached);
+
+        return new Doctrine_ORM_Query_ParserResult(
+            $cached[0],
+            self::_getQueryComponents($cached[1]),
+            $cached[2],
+            $cached[3]
+        );
+    }
+
+
+    /**
+     * @nodoc
+     */
+    protected static function _getQueryComponents($query, $cachedQueryComponents)
+    {
+        $queryComponents = array();
+
+        foreach ($cachedQueryComponents as $alias => $components) {
+            $e = explode('.', $components[0]);
+
+            if (count($e) === 1) {
+                $queryComponents[$alias]['mapper'] = $query->getConnection()->getMapper($e[0]);
+                $queryComponents[$alias]['table'] = $queryComponents[$alias]['mapper']->getTable();
+            } else {
+                $queryComponents[$alias]['parent'] = $e[0];
+                $queryComponents[$alias]['relation'] = $queryComponents[$e[0]]['table']->getAssociation($e[1]);
+                $queryComponents[$alias]['mapper'] = $query->getConnection()->getMapper($queryComponents[$alias]['relation']->getTargetEntityName());
+                $queryComponents[$alias]['table'] = $queryComponents[$alias]['mapper']->getTable();
+            }
+
+            if (isset($v[1])) {
+                $queryComponents[$alias]['agg'] = $components[1];
+            }
+
+            if (isset($v[2])) {
+                $queryComponents[$alias]['map'] = $components[2];
+            }
+        }
+
+        return $queryComponents;
+    }
+
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Exception.php

+<?php
+/*
+ *  $Id: Exception.php 4628 2008-07-04 16:32:19Z romanb $
+ *
+ * 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.phpdoctrine.org>.
+ */
+
+/**
+ * Doctrine_ORM_Query_Exception
+ *
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        www.phpdoctrine.org
+ * @since       1.0
+ * @version     $Revision: 4628 $
+ * @author      Konsta Vesterinen <kvesteri@cc.hut.fi>
+ */
+class Doctrine_ORM_Query_Exception extends Doctrine_Exception
+{
+    public static function nonUniqueResult()
+    {
+        return new self("The query contains more than one result.");   
+    }
+}

lib/Doctrine/ORM/Query/Parser/AbstractSchemaName.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * AbstractSchemaName ::= identifier
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_AbstractSchemaName extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+    
+    public function syntax($paramHolder)
+    {
+        // AbstractSchemaName ::= identifier
+        $this->_AST = $this->AST('AbstractSchemaName');
+
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_IDENTIFIER);
+        $this->_AST->setComponentName($this->_parser->token['value']);
+    }
+
+
+    public function semantical($paramHolder)
+    {
+        $componentName = $this->_AST->getComponentName();
+
+        // Check if we are dealing with a real Doctrine_Entity or not
+        if ( ! $this->_isDoctrineEntity($componentName)) {
+            $this->_parser->semanticalError(
+                "Defined entity '" . $companyName . "' is not a valid Doctrine_Entity."
+            );
+        }
+
+        // Return AST node
+        return $this->_AST;
+    }
+    
+    
+    protected function _isDoctrineEntity($componentName)
+    {
+        return class_exists($componentName) && is_subclass_of($componentName, 'Doctrine_ORM_Entity');
+    }
+}

lib/Doctrine/ORM/Query/Parser/AliasIdentificationVariable.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * AliasIdentificationVariable = identifier
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_AliasIdentificationVariable extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+    
+    public function syntax($paramHolder)
+    {
+        // AliasIdentificationVariable = identifier
+        $this->_AST = $this->AST('AliasIdentificationVariable');
+
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_IDENTIFIER);
+        $this->_AST->setComponentAlias($this->_parser->token['value']);
+    }
+
+
+    public function semantical($paramHolder)
+    {
+        $parserResult = $this->_parser->getParserResult();
+
+        if ($parserResult->hasQueryComponent($this->_AST->getComponentAlias())) {
+            // We should throw semantical error if there's already a component for this alias
+            $queryComponent = $parserResult->getQueryComponent($this->_AST->getComponentAlias());
+            $componentName = $queryComponent['metadata']->getClassName();
+
+            $message  = "Cannot re-declare component alias '" . $this->_AST->getComponentAlias() . "'. "
+                      . "It was already declared for component '" . $componentName . "'.";
+
+            $this->_parser->semanticalError($message);
+        }
+
+        return $this->_AST;
+    }
+}

lib/Doctrine/ORM/Query/Parser/DeleteStatement.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * DeleteStatement ::= DeleteClause [WhereClause]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_DeleteStatement extends Doctrine_ORM_Query_Parser
+{
+    protected $_AST = null;
+
+
+    public function syntax($paramHolder)
+    {
+        // DeleteStatement ::= DeleteClause [WhereClause]
+        $this->_AST = $this->AST('DeleteStatement');
+
+        $this->_AST->setDeleteClause($this->parse('DeleteClause', $paramHolder));
+
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_WHERE)) {
+            $this->_AST->setWhereClause($this->parse('WhereClause', $paramHolder));
+        }
+        
+        // Return AST node
+        return $this->_AST;
+    }
+}

lib/Doctrine/ORM/Query/Parser/Exception.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * Doctrine_ORM_Query_Parser_Exception
+ *
+ * @package     Doctrine
+ * @subpackage  Query
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       1.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_Exception extends Doctrine_ORM_Query_Exception
+{
+}

lib/Doctrine/ORM/Query/Parser/FieldIdentificationVariable.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * FieldIdentificationVariable ::= identifier
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_FieldIdentificationVariable extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+    
+    public function syntax($paramHolder)
+    {
+        // FieldIdentificationVariable ::= identifier
+        $this->_AST = $this->AST('FieldIdentificationVariable');
+
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_IDENTIFIER);
+        $this->_AST->setFieldName($this->_parser->token['value']);
+        
+        // Return AST node
+        return $this->_AST;
+    }
+
+
+    public function semantical($paramHolder)
+    {
+        $parserResult = $this->_parser->getParserResult();
+
+        // [TODO] Check for field existance somewhere
+
+        // Return AST node
+        return $this->_AST;
+    }
+}

lib/Doctrine/ORM/Query/Parser/FromClause.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       1.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_FromClause extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+
+    public function syntax($paramHolder)
+    {
+        // FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}
+        $this->_AST = $this->AST('FromClause');
+        
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_FROM);
+
+        $this->_AST->addIdentificationVariableDeclaration(
+            $this->parse('IdentificationVariableDeclaration', $paramHolder)
+        );
+
+        while ($this->_isNextToken(',')) {
+            $this->_parser->match(',');
+
+            $this->_AST->addIdentificationVariableDeclaration(
+                $this->parse('IdentificationVariableDeclaration', $paramHolder)
+            );
+        }
+        
+        // Return AST node
+        return $this->_AST;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/IdentificationVariable.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * IdentificationVariable ::= identifier
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_IdentificationVariable extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+    
+    public function syntax($paramHolder)
+    {
+        // IdentificationVariable ::= identifier
+        $this->_AST = $this->AST('IdentificationVariable');
+
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_IDENTIFIER);
+        $this->_AST->setComponentAlias($this->_parser->token['value']);
+    }
+
+
+    public function semantical($paramHolder)
+    {
+        $parserResult = $this->_parser->getParserResult();
+
+        if ( ! $parserResult->hasQueryComponent($this->_AST->getComponentAlias())) {
+            // We should throw semantical error if we cannot find the component alias
+            $message  = "No entity related to declared alias '" . $this->_AST->getComponentAlias() 
+                      . "' near '" . $this->_parser->getQueryPiece($this->_parser->token) . "'.";
+
+            $this->_parser->semanticalError($message);
+        }
+
+        // Return AST node
+        return $this->_AST;
+    }
+}

lib/Doctrine/ORM/Query/Parser/IdentificationVariableDeclaration.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}*
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       1.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_IdentificationVariableDeclaration extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+
+    public function syntax($paramHolder)
+    {
+        // IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}*
+        $this->_AST = $this->AST('IdentificationVariableDeclaration');
+        
+        $this->_AST->setRangeVariableDeclaration($this->parse('RangeVariableDeclaration', $paramHolder));
+
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_INDEX)) {
+            $this->_AST->setIndexBy($this->parse('IndexBy', $paramHolder));
+        }
+
+        while (
+            $this->_isNextToken(Doctrine_ORM_Query_Token::T_LEFT) ||
+            $this->_isNextToken(Doctrine_ORM_Query_Token::T_INNER) ||
+            $this->_isNextToken(Doctrine_ORM_Query_Token::T_JOIN)
+        ) {
+            $this->_AST->addJoinVariableDeclaration($this->parse('JoinVariableDeclaration', $paramHolder));
+        }
+    }
+    
+    
+    public function semantical($paramHolder)
+    {
+        // If we have an INDEX BY RangeVariableDeclaration
+        if ($this->_AST->getIndexby() !== null) {
+            // Grab Range component alias
+            $rangeComponentAlias = $this->_AST->getRangeVariableDeclaration()
+                ->getAliasIdentificationVariable()->getComponentAlias();
+                
+            // Grab IndexBy component alias
+            $indexComponentAlias = $this->_AST->getIndexBy()
+                ->getSimpleStateFieldPathExpression()->getIdentificationVariable()->getComponentAlias();
+
+            // Check if we have same component being used in index
+            if ($rangeComponentAlias !== $indexComponentAlias) {
+                $message = "Invalid aliasing. Cannot index by '" . $indexComponentAlias
+                         . "' inside '" . $rangeComponentAlias . "' scope.";
+
+                $this->_parser->semanticalError($message);
+            }
+        }
+
+        // Return AST node
+        return $this->_AST;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/IndexBy.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * IndexBy ::= "INDEX" "BY" SimpleStateFieldPathExpression
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_IndexBy extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+
+    public function syntax($paramHolder)
+    {
+        // IndexBy ::= "INDEX" "BY" SimpleStateFieldPathExpression
+        $this->_AST = $this->AST('IndexBy');
+        
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_INDEX);
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_BY);
+
+        $this->_AST->setSimpleStateFieldPathExpression($this->parse('SimpleStateFieldPathExpression', $paramHolder));
+    }
+    
+    
+    public function semantical($paramHolder)
+    {
+        // Retrieving required information
+        $parserResult = $this->_parser->getParserResult();
+        
+        // Grab INDEX BY information
+        $componentAlias = $this->_AST->getSimpleStateFieldPathExpression()
+            ->getIdentificationVariable()->getComponentAlias();
+        $componentFieldName = $this->_AST->getSimpleStateFieldPathExpression()
+            ->getSimpleStateField()->getFieldName();
+
+        // Trying to retrieve related query component
+        try {
+            $queryComponent = $parserResult->getQueryComponent($componentAlias);
+            $classMetadata = $queryComponent['metadata'];
+        } catch (Doctrine_Exception $e) {
+            $this->_parser->semanticalError($e->getMessage());
+
+            return;
+        }
+        
+        // The INDEX BY field must be either the (primary && not part of composite pk) || (unique && notnull)
+        $columnMapping = $classMetadata->getFieldMapping($componentFieldName);
+
+        if ( 
+            ! $classMetadata->isIdentifier($componentFieldName) && 
+            ! $classMetadata->isUniqueField($componentFieldName) && 
+            ! $classMetadata->isNotNull($componentFieldName)
+        ) {
+            $this->_parser->semanticalError(
+                "Field '" . $componentFieldName . "' of component  '" . $classMetadata->getClassName() .
+                "' must be unique and notnull to be used as index.",
+                $this->_parser->token
+            );
+        }
+
+        if ($classMetadata->isIdentifier($componentFieldName) && $classMetadata->isIdentifierComposite()) {
+            $this->_parser->semanticalError(
+                "Field '" . $componentFieldName . "' of component  '" . $classMetadata->getClassName() .
+                "' must be primary and not part of a composite primary key to be used as index.",
+                $this->_parser->token
+            );
+        }
+
+        $queryComponent['map'] = $componentFieldName;
+        $parserResult->setQueryComponent($componentAlias, $queryComponent);
+
+        // Return AST node
+        return $this->_AST;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/Join.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression
+ *          ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_Join extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+
+    public function syntax($paramHolder)
+    {
+        //  Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression
+        //           ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression]
+        $this->_AST = $this->AST('Join');
+
+        // Check Join type
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_LEFT)) {
+            $this->_parser->match(Doctrine_ORM_Query_Token::T_LEFT);
+
+            // Possible LEFT OUTER join
+            if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_OUTER)) {
+                $this->_parser->match(Doctrine_ORM_Query_Token::T_OUTER);
+
+                $this->_AST->setJoinType(Doctrine_ORM_Query_AST_Join::JOIN_TYPE_LEFTOUTER);
+            } else {
+                $this->_AST->setJoinType(Doctrine_ORM_Query_AST_Join::JOIN_TYPE_LEFT);
+            }
+        } else if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_INNER)) {
+            // Default Join type. Not need to setJoinType.
+            $this->_parser->match(Doctrine_ORM_Query_Token::T_INNER);
+        }
+
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_JOIN);
+        
+        $this->_AST->setJoinAssociationPathExpression($this->parse('JoinAssociationPathExpression', $paramHolder));
+        
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_AS)) {
+            $this->_parser->match(Doctrine_ORM_Query_Token::T_AS);
+        }
+        
+        $this->_AST->setAliasIdentificationVariable($this->parse('AliasIdentificationVariable', $paramHolder));
+        
+        // Check Join where type
+        if (
+            $this->_isNextToken(Doctrine_ORM_Query_Token::T_ON) || 
+            $this->_isNextToken(Doctrine_ORM_Query_Token::T_WITH)
+        ) {
+            // Apply matches and adjusts
+            if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_ON)) {
+                $this->_parser->match(Doctrine_ORM_Query_Token::T_ON);
+                
+                $this->_AST->setWhereType(Doctrine_ORM_Query_AST_Join::JOIN_WHERE_ON);
+            } else {
+                // Default Join where type. Not need to setWhereType.
+                $this->_parser->match(Doctrine_ORM_Query_Token::T_WITH);
+            }
+
+            $this->_AST->setConditionalExpression($this->parse('ConditionalExpression', $paramHolder));
+        }
+
+        // Return AST node
+        return $this->_AST;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/JoinVariableDeclaration.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * JoinVariableDeclaration ::= Join [IndexBy]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       1.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_JoinVariableDeclaration extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+    
+    public function syntax($paramHolder)
+    {
+        // JoinVariableDeclaration ::= Join [IndexBy]
+        $this->_AST = $this->AST('JoinVariableDeclaration');
+        
+        $this->_AST->setJoin($this->parse('Join', $paramHolder));
+
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_INDEX)) {
+            $this->_AST->setIndexBy($this->parse('IndexBy', $paramHolder));
+        }
+    }
+
+
+    public function semantical($paramHolder)
+    {
+        // If we have an INDEX BY JoinVariableDeclaration
+        if ($this->_AST->getIndexby() !== null) {
+            // Grab Join component alias
+            $joinComponentAlias = $this->_AST->getJoin()
+                ->getAliasIdentificationVariable()->getComponentAlias();
+                
+            // Grab IndexBy component alias
+            $indexComponentAlias = $this->_AST->getIndexBy()
+                ->getSimpleStateFieldPathExpression()->getIdentificationVariable()->getComponentAlias();
+
+            // Check if we have same component being used in index
+            if ($joinComponentAlias !== $indexComponentAlias) {
+                $message = "Invalid aliasing. Cannot index by '" . $indexComponentAlias
+                         . "' inside '" . $joinComponentAlias . "' scope.";
+
+                $this->_parser->semanticalError($message);
+            }
+        }
+
+        // Return AST node
+        return $this->_AST;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/QueryLanguage.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
+ *
+ * @package     Doctrine
+ * @subpackage  Query
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_QueryLanguage extends Doctrine_ORM_Query_ParserRule
+{
+    public function syntax($paramHolder)
+    {
+        // QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
+        switch ($this->_parser->lookahead['type']) {
+            case Doctrine_ORM_Query_Token::T_SELECT:
+                return $this->parse('SelectStatement', $paramHolder);
+            break;
+
+            case Doctrine_ORM_Query_Token::T_UPDATE:
+                return $this->parse('UpdateStatement', $paramHolder);
+            break;
+
+            case Doctrine_ORM_Query_Token::T_DELETE:
+                return $this->parse('DeleteStatement', $paramHolder);
+            break;
+
+            default:
+                $this->_parser->syntaxError('SELECT, UPDATE or DELETE');
+            break;
+        }
+    }
+}

lib/Doctrine/ORM/Query/Parser/RangeVariableDeclaration.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       1.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_RangeVariableDeclaration extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+
+    public function syntax($paramHolder)
+    {
+        // RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
+        $this->_AST = $this->AST('RangeVariableDeclaration');
+        
+        $this->_AST->setAbstractSchemaName($this->parse('AbstractSchemaName', $paramHolder));
+        
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_AS)) {
+            $this->_parser->match(Doctrine_ORM_Query_Token::T_AS);
+        }
+
+        $this->_AST->setAliasIdentificationVariable($this->parse('AliasIdentificationVariable', $paramHolder));
+    }
+    
+    
+    public function semantical($paramHolder)
+    {
+        $parserResult = $this->_parser->getParserResult();
+        $componentName = $this->_AST->getAbstractSchemaName()->getComponentName();
+        $componentAlias = $this->_AST->getAliasIdentificationVariable()->getComponentAlias();
+
+        // Check if we already have a component defined without an alias
+        if ($componentAlias === null && $parserResult->hasQueryComponent($componentName)) {
+            $this->_parser->semanticalError(
+                "Cannot re-declare component '{$componentName}'. Please assign an alias to it."
+            );
+        // Define new queryComponent since it does not exist yet
+        } else {
+            // Retrieving ClassMetadata and Mapper
+            try {
+                $classMetadata = $this->_em->getClassMetadata($componentName);
+    
+                // Building queryComponent
+                $queryComponent = array(
+                    'metadata' => $classMetadata,
+                    'parent'   => null,
+                    'relation' => null,
+                    'map'      => null,
+                    'scalar'   => null,
+                );
+            } catch (Doctrine_Exception $e) {
+                $this->_parser->semanticalError($e->getMessage());
+            }
+
+            // Inspect for possible non-aliasing
+            if ($componentAlias === null) {
+                $componentAlias = $componentName;
+            }
+    
+            $tableAlias = $parserResult->generateTableAlias($classMetadata->getClassName());
+            $parserResult->setQueryComponent($componentAlias, $queryComponent);
+            $parserResult->setTableAlias($tableAlias, $componentAlias);
+        }
+        
+        // Return AST node
+        return $this->_AST;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/SelectClause.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_SelectClause extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+    protected $_selectExpressions = array();
+
+
+    public function syntax($paramHolder)
+    {
+        // SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
+        $this->_AST = $this->AST('SelectClause');
+
+        $this->_parser->match(Doctrine_ORM_Query_Token::T_SELECT);
+
+        // Inspecting if we are in a DISTINCT query
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_DISTINCT)) {
+            $this->_parser->match(Doctrine_ORM_Query_Token::T_DISTINCT);
+
+            $this->_AST->setIsDistinct(true);
+        }
+
+        // Process SelectExpressions (1..N)
+        $this->_selectExpressions[] = $this->parse('SelectExpression', $paramHolder);
+
+        while ($this->_isNextToken(',')) {
+            $this->_parser->match(',');
+            
+            $this->_selectExpressions[] = $this->parse('SelectExpression', $paramHolder);
+        }
+    }
+
+
+    public function semantical($paramHolder)
+    {
+        // We need to validate each SelectExpression
+        for ($i = 0, $l = count($this->_selectExpressions); $i < $l; $i++) {
+             $this->_AST->addSelectExpression($this->_selectExpressions[$i]->semantical($paramHolder));
+        }
+        
+        // Return AST node
+        return $this->_AST;
+    }
+}

lib/Doctrine/ORM/Query/Parser/SelectExpression.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * SelectExpression ::= IdentificationVariable ["." "*"] |
+ *                      (StateFieldPathExpression | AggregateExpression | "(" Subselect ")" )
+ *                      [["AS"] FieldIdentificationVariable]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       1.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_SelectExpression extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+
+    public function syntax($paramHolder)
+    {
+        // SelectExpression ::= IdentificationVariable ["." "*"] |
+        //                      (StateFieldPathExpression | AggregateExpression | "(" Subselect ")" )
+        //                      [["AS"] FieldIdentificationVariable]
+        
+        // First we recognize for an IdentificationVariable (Component alias)
+        if ($this->_isIdentificationVariable()) {
+            $identificationVariable = $this->parse('IdentificationVariable', $paramHolder);
+            
+            // Inspecting if we are in a ["." "*"]
+            if ($this->_isNextToken('.')) {
+                $this->_parser->match('.');
+                $this->_parser->match('*');
+            }
+            
+            return $identificationVariable;
+        }
+    }
+    
+    
+    protected function _isIdentificationVariable()
+    {
+        // Retrying to recoginize this grammar: IdentificationVariable ["." "*"]
+        $token = $this->_parser->lookahead;
+        $this->_parser->getScanner()->resetPeek();
+
+        // We have an identifier here
+        if ($token['type'] === Doctrine_ORM_Query_Token::T_IDENTIFIER) {
+            $token = $this->_parser->getScanner()->peek();
+
+            // If we have a dot ".", then next char must be the "*"
+            if ($token['value'] === '.') {
+                $token = $this->_parser->getScanner()->peek();
+                
+                return $token['value'] === '*';
+            }
+        }
+        
+        return false;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/SelectStatement.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_SelectStatement extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+    protected $_selectClause = null;
+
+
+    public function syntax($paramHolder)
+    {
+        // SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
+        $this->_AST = $this->AST('SelectStatement');
+
+        // Disable the semantical check for SelectClause now. This is needed
+        // since we dont know the query components yet (will be known only
+        // when the FROM and WHERE clause are processed).
+        $paramHolder->set('semanticalCheck', false);
+        $this->_selectClause = $this->parse('SelectClause', $paramHolder);
+        $paramHolder->remove('semanticalCheck');
+        
+        $this->_AST->setFromClause($this->parse('FromClause', $paramHolder));
+
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_WHERE)) {
+            $this->_AST->setWhereClause($this->parse('WhereClause', $paramHolder));
+        }
+
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_GROUP)) {
+            $this->_AST->setGroupByClause($this->parse('GroupByClause', $paramHolder));
+        }
+
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_HAVING)) {
+            $this->_AST->setHavingClause($this->parse('HavingClause', $paramHolder));
+        }
+
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_ORDER)) {
+            $this->_AST->setOrderByClause($this->parse('OrderByClause', $paramHolder));
+        }
+    }
+
+
+    public function semantical($paramHolder)
+    {
+        // We need to invoke the semantical check of SelectClause here, since
+        // it was not yet checked.
+        // The semantical checks will be forwarded to all SelectClause dependant grammar rules
+        $this->_AST->setSelectClause($this->_selectClause->semantical($paramHolder));
+        
+        // Return AST node
+        return $this->_AST;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/SimpleStateField.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * SimpleStateField ::= FieldIdentificationVariable
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_SimpleStateField extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+ 
+    public function syntax($paramHolder)
+    {
+        // SimpleStateField ::= FieldIdentificationVariable
+        return $this->parse('FieldIdentificationVariable', $paramHolder);
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/SimpleStateFieldPathExpression.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * SimpleStateFieldPathExpression ::= IdentificationVariable "." SimpleStateField
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_SimpleStateFieldPathExpression extends Doctrine_ORM_Query_ParserRule
+{
+    protected $_AST = null;
+    
+ 
+    public function syntax($paramHolder)
+    {
+        // SimpleStateFieldPathExpression ::= IdentificationVariable "." SimpleStateField
+        $this->_AST = $this->AST('SimpleStateFieldPathExpression');
+        
+        $this->_AST->setIdentificationVariable($this->parse('IdentificationVariable', $paramHolder));
+
+        $this->_parser->match('.');
+        
+        $this->_AST->setSimpleStateField($this->parse('SimpleStateField', $paramHolder));
+    }
+
+    
+    public function semantical($paramHolder)
+    {
+        $parserResult = $this->_parser->getParserResult();
+        $componentAlias = $this->_AST->getIdentificationVariable()->getComponentAlias();
+        $componentFieldName = $this->_AST->getSimpleStateField()->getFieldName();
+
+        // We need to make sure field exists
+        try {
+            $queryComponent = $parserResult->getQueryComponent($componentAlias);
+            $classMetadata = $queryComponent['metadata'];
+        } catch (Doctrine_Exception $e) {
+            $this->_parser->semanticalError($e->getMessage());
+
+            return;
+        }
+
+        if ($classMetadata instanceof Doctrine_ClassMetadata && ! $classMetadata->hasField($componentFieldName)) {
+            $this->_parser->semanticalError(
+                "Cannot use key mapping. Field '" . $componentFieldName . "' " .
+                "does not exist in component '" . $classMetadata->getClassName() . "'.",
+                $this->_parser->token
+            );
+        }
+
+        // Return AST node
+        return $this->_AST;
+    }
+}
\ No newline at end of file

lib/Doctrine/ORM/Query/Parser/UpdateStatement.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * UpdateStatement ::= UpdateClause [WhereClause]
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_Parser_UpdateStatement extends Doctrine_ORM_Query_Parser
+{
+    protected $_AST = null;
+
+
+    public function syntax($paramHolder)
+    {
+        // UpdateStatement ::= UpdateClause [WhereClause]
+        $this->_AST = $this->AST('UpdateStatement');
+
+        $this->_AST->setUpdateClause($this->parse('UpdateClause', $paramHolder));
+
+        if ($this->_isNextToken(Doctrine_ORM_Query_Token::T_WHERE)) {
+            $this->_AST->setWhereClause($this->parse('WhereClause', $paramHolder));
+        }
+        
+        // Return AST node
+        return $this->_AST;
+    }
+}

lib/Doctrine/ORM/Query/ParserParamHolder.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * Production variables holder
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_ParserParamHolder
+{
+    protected static $_instance;
+
+    protected $_data;
+
+
+    protected function __construct()
+    {
+        $this->free();
+    }
+
+
+    public static function create()
+    {
+        if ( ! isset(self::$_instance)) {
+            self::$_instance = new self;
+        }
+
+        return self::$_instance;
+    }
+
+
+    public function free()
+    {
+        $this->_data = array();
+    }
+
+
+    public function set($offset, $value)
+    {
+        $this->_data[$offset] = $value;
+    }
+
+
+    public function get($offset)
+    {
+        return isset($this->_data[$offset]) ? $this->_data[$offset] : null;
+    }
+
+
+    public function has($offset)
+    {
+        return isset($this->_data[$offset]);
+    }
+
+
+    public function remove($offset)
+    {
+        if ($this->has($offset)) {
+            $this->_data[$offset] = null;
+            unset($this->_data[$offset]);
+        }
+    }
+}

lib/Doctrine/ORM/Query/ParserResult.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * Doctrine_ORM_Query_ParserResult
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+class Doctrine_ORM_Query_ParserResult extends Doctrine_ORM_Query_AbstractResult
+{
+    /**
+     * The EntityManager.
+     *
+     * @var Doctrine_EntityManager
+     */
+    protected $_em;
+
+    /**
+     * A simple array keys representing table aliases and values table alias
+     * seeds. The seeds are used for generating short table aliases.
+     *
+     * @var array $_tableAliasSeeds
+     */
+    protected $_tableAliasSeeds = array();
+
+    /**
+     * Simple array of keys representing the fields used in query.
+     *
+     * @var array $_queryFields
+     */
+    protected $_queryFields = array();
+    
+    
+    /**
+     * Sets the Entity Manager.
+     *
+     * @param Doctrine_EntityManager $em The Entity Manager.
+     */
+    public function setEntityManager($em)
+    {
+        $this->_em = $em;
+    }
+
+
+    /**
+     * Gets the Entity Manager.
+     *
+     * @return Doctrine_EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->_em;
+    }
+
+
+    /**
+     * @nodoc
+     */
+    public function setSqlExecutor(Doctrine_ORM_Query_SqlExecutor_Abstract $executor)
+    {
+        $this->_data = $executor;
+    }
+
+
+    /**
+     * @nodoc
+     */
+    public function getSqlExecutor()
+    {
+        return $this->_data;
+    }
+
+
+    /**
+     * Defines the mapping fields.
+     *
+     * @param array $queryFields Query fields.
+     */
+    public function setQueryFields(array $queryFields)
+    {
+        $this->_queryFields = $queryFields;
+    }
+
+
+    /**
+     * Sets the declaration for given field alias.
+     *
+     * @param string $fieldAlias The field alias to set the declaration to.
+     * @param string $queryField Alias declaration.
+     */
+    public function setQueryField($fieldAlias, $queryField)
+    {
+        $this->_queryFields[$fieldAlias] = $queryField;
+    }
+
+
+    /**
+     * Gets the mapping fields.
+     *
+     * @return array Query fields.
+     */
+    public function getQueryFields()
+    {
+        return $this->_queryFields;
+    }
+
+
+    /**
+     * Get the declaration for given field alias.
+     *
+     * @param string $fieldAlias The field alias the retrieve the declaration from.
+     * @return array Alias declaration.
+     */
+    public function getQueryField($fieldAlias)
+    {
+        if ( ! isset($this->_queryFields[$fieldAlias])) {
+            throw new Doctrine_ORM_Query_Exception('Unknown query field ' . $fieldAlias);
+        }
+
+        return $this->_queryFields[$fieldAlias];
+    }
+
+
+    /**
+     * Whether or not this object has a declaration for given field alias.
+     *
+     * @param string $fieldAlias Field alias the retrieve the declaration from.
+     * @return boolean True if this object has given alias, otherwise false.
+     */
+    public function hasQueryField($fieldAlias)
+    {
+        return isset($this->_queryFields[$fieldAlias]);
+    }
+
+
+    /**
+     * Generates a table alias from given table name and associates 
+     * it with given component alias
+     *
+     * @param string $componentName Component name to be associated with generated table alias
+     * @return string               Generated table alias
+     */
+    public function generateTableAlias($componentName)
+    {
+        $baseAlias = strtolower(preg_replace('/[^A-Z]/', '\\1', $componentName));
+
+        // We may have a situation where we have all chars are lowercased
+        if ( $baseAlias == '' ) {
+            // We simply grab the first 2 chars of component name
+            $baseAlias = substr($componentNam, 0, 2);
+        }
+
+        $alias = $baseAlias;
+
+        if ( ! isset($this->_tableAliasSeeds[$baseAlias])) {
+            $this->_tableAliasSeeds[$baseAlias] = 1;
+        } else {
+            $alias .= $this->_tableAliasSeeds[$baseAlias]++;
+        }
+
+        return $alias;
+    }
+}

lib/Doctrine/ORM/Query/ParserResultDummy.php

+<?php
+
+/**
+ * This class is just an intermediate implementation for refactoring purposes
+ * and will be replaced by the ParserResult class of the new DQL parser branch.
+ *
+ */
+class Doctrine_ORM_Query_ParserResultDummy
+{
+    private $_isMixedQuery;
+    private $_dbStatement;
+    private $_isIdentityQuery;
+    private $_hydrationMode;
+    private $_tableToClassAliasMap;
+    private $_queryComponents;
+    
+    
+    public function isMixedQuery()
+    {
+        return $this->_isMixedQuery;
+    }
+    
+    public function isIdentityQuery()
+    {
+        return $this->_isIdentityQuery;
+    }
+    
+    public function setMixedQuery($bool)
+    {
+        $this->_isMixedQuery = (bool) $bool;
+    }
+    
+    public function getDatabaseStatement()
+    {
+        return $this->_dbStatement;
+    }
+    
+    public function setDatabaseStatement($stmt)
+    {
+        $this->_dbStatement = $stmt;
+    }
+    
+    public function getHydrationMode()
+    {
+        return $this->_hydrationMode;
+    }
+    
+    public function setHydrationMode($hydrationMode)
+    {
+        $this->_hydrationMode = $hydrationMode;
+    }
+    
+    public function getTableToClassAliasMap()
+    {
+        return $this->_tableToClassAliasMap;
+    }
+    
+    public function setTableToClassAliasMap(array $map)
+    {
+        $this->_tableToClassAliasMap = $map;
+    }
+    
+    public function setQueryComponents(array $queryComponents)
+    {
+        $this->_queryComponents = $queryComponents;
+    }
+    
+    public function getQueryComponents()
+    {
+        return $this->_queryComponents;
+    }
+}
+
+
+?>
\ No newline at end of file

lib/Doctrine/ORM/Query/ParserRule.php

+<?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.phpdoctrine.org>.
+ */
+
+/**
+ * An abstract base class for the productions of the Doctrine Query Language
+ * context-free grammar.
+ *
+ * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author      Janne Vanhala <jpvanhal@cc.hut.fi>
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        http://www.phpdoctrine.org
+ * @since       2.0
+ * @version     $Revision$
+ */
+abstract class Doctrine_ORM_Query_ParserRule
+{
+    /**
+     * @nodoc
+     */
+    const SQLALIAS_SEPARATOR = '__';
+
+
+    /**
+     * @nodoc
+     */
+    const DEFAULT_QUERYCOMPONENT = 'dctrn';
+
+
+    /**
+     * Parser object
+     *
+     * @var Doctrine_ORM_Query_Parser
+     */
+    protected $_parser;
+    
+    /**
+     * The EntityManager.
+     *
+     * @var EntityManager
+     */
+    protected $_em;
+
+
+    /**
+     * Creates a new production object.
+     *
+     * @param Doctrine_ORM_Query_Parser $parser a parser object
+     */
+    public function __construct(Doctrine_ORM_Query_Parser $parser)
+    {
+        $this->_parser = $parser;
+        $this->_em = $this->_parser->getEntityManager();
+    }
+
+
+    protected function _isNextToken($token)
+    {
+        $la = $this->_parser->lookahead;
+        return ($la['type'] === $token || $la['value'] === $token);
+    }
+
+
+    protected function _isFunction()
+    {
+        $la = $this->_parser->lookahead;
+        $next = $this->_parser->getScanner()->peek();
+        return ($la['type'] === Doctrine_ORM_Query_Token::T_IDENTIFIER && $next['value'] === '(');
+    }
+
+
+    protected function _isSubselect()
+    {
+        $la = $this->_parser->lookahead;
+        $next = $this->_parser->getScanner()->peek();
+        return ($la['value'] === '(' && $next['type'] === Doctrine_ORM_Query_Token::T_SELECT);
+    }
+
+
+    /**
+     * Executes the grammar rule using the specified parameters.
+     *
+     * @param string $RuleName BNF Grammar Rule name
+     * @param array $paramHolder Production parameter holder
+     * @return Doctrine_ORM_Query_ParserRule
+     */
+    public function parse($RuleName, $paramHolder)
+    {
+        $BNFGrammarRule = $this->_getGrammarRule($RuleName);
+
+        //echo "Processing class: " . get_class($BNFGrammarRule) . "...\n";
+        //echo "Params: " . var_export($paramHolder, true) . "\n";
+
+        // Syntax check
+        if ( ! $paramHolder->has('syntaxCheck') || $paramHolder->get('syntaxCheck') === true) {
+            //echo "Processing syntax checks of " . $RuleName . "...\n";
+
+            $return = $BNFGrammarRule->syntax($paramHolder);
+
+            if ($return !== null) {
+                //echo "Returning Gramma Rule class: " . (is_object($return) ? get_class($return) : $return) . "...\n";
+
+                return $return;
+            }
+        }
+
+        // Semantical check
+        if ( ! $paramHolder->has('semanticalCheck') || $paramHolder->get('semanticalCheck') === true) {
+            //echo "Processing semantical checks of " . $RuleName . "...\n";
+
+            $return = $BNFGrammarRule->semantical($paramHolder);
+
+            if ($return !== null) {
+                //echo "Returning Gramma Rule class: " . (is_object($return) ? get_class($return) : $return) . "...\n";
+
+                return $return;
+            }
+        }
+
+        return $BNFGrammarRule;
+    }
+
+
+    /**
+     * Returns a grammar rule object with the given name.
+     *
+     * @param string $name grammar rule name
+     * @return Doctrine_ORM_Query_ParserRule
+     */
+    protected function _getGrammarRule($name)
+    {
+        $class = 'Doctrine_ORM_Query_Parser_' . $name;
+
+        //echo $class . "\r\n";
+        //TODO: This expensive check is not necessary. Should be removed at the end.
+        //      "new $class" will throw an error anyway if the class is not found.
+        if ( ! class_exists($class)) {
+            throw new Doctrine_ORM_Query_Parser_Exception(
+                "Unknown Grammar Rule '$name'. Could not find related compiler class."
+            );
+        }
+
+        return new $class($this->_parser);
+    }
+    
+    
+    /**
+     * Creates an AST node with the given name.
+     *
+     * @param string $AstName AST node name
+     * @return Doctrine_ORM_Query_AST
+     */
+    public function AST($AstName)
+    {
+        $class = 'Doctrine_ORM_Query_AST_' . $AstName;
+
+        //echo $class . "\r\n";
+
+        if ( ! class_exists($class)) {
+            throw new Doctrine_ORM_Query_Parser_Exception(
+                "Unknown AST node '" . $AstName . "'. Could not find related compiler class."
+            );
+        }
+
+        return new $class($this->_parser->getParserResult());
+    }
+
+    /**
+     * @nodoc
+     */
+    abstract public function syntax($paramHolder);
+
+
+    /**
+     * @nodoc
+     */
+    public function semantical($paramHolder)
+    {
+    }
+    
+    public function getParser()
+    {
+        return $this->_parser;
+    }
+}