Merge remote-tracking branch 'origin/master' into DDC-551

Conflicts:
	lib/Doctrine/ORM/Persisters/BasicEntityPersister.php
	lib/Doctrine/ORM/Query.php

.gitignore

@@ -7,3 +7,6 @@ download/
 lib/api/
 lib/Doctrine/Common
 lib/Doctrine/DBAL
+/.settings/
+.buildpath
+.project

.travis.yml

@@ -0,0 +1,19 @@
+language: php
+
+php:
+  - 5.3
+  - 5.4
+env:
+  - DB=mysql
+  - DB=pgsql
+  - DB=sqlite
+
+before_script:
+  - sh -c "if [ '$DB' = 'pgsql' ]; then psql -c 'DROP DATABASE IF EXISTS doctrine_tests;' -U postgres; fi"
+  - sh -c "if [ '$DB' = 'pgsql' ]; then psql -c 'DROP DATABASE IF EXISTS doctrine_tests_tmp;' -U postgres; fi"
+  - sh -c "if [ '$DB' = 'pgsql' ]; then psql -c 'create database doctrine_tests;' -U postgres; fi"
+  - sh -c "if [ '$DB' = 'pgsql' ]; then psql -c 'create database doctrine_tests_tmp;' -U postgres; fi"
+  - sh -c "if [ '$DB' = 'mysql' ]; then mysql -e 'create database IF NOT EXISTS doctrine_tests_tmp;create database IF NOT EXISTS doctrine_tests;'; fi"
+  - git submodule update --init
+
+script: phpunit --configuration tests/travis/$DB.travis.xml

README.markdown

@@ -1,14 +1,18 @@
 # Doctrine 2 ORM
 
+Master: [![Build Status](https://secure.travis-ci.org/doctrine/doctrine2.png?branch=master)](http://travis-ci.org/doctrine/doctrine2)
+2.1.x: [![Build Status](https://secure.travis-ci.org/doctrine/doctrine2.png?branch=2.1.x)](http://travis-ci.org/doctrine/doctrine2)
+
 Doctrine 2 is an object-relational mapper (ORM) for PHP 5.3.2+ that provides transparent persistence
 for PHP objects. It sits on top of a powerful database abstraction layer (DBAL). One of its key features
 is the option to write database queries in a proprietary object oriented SQL dialect called Doctrine Query Language (DQL),
 inspired by Hibernates HQL. This provides developers with a powerful alternative to SQL that maintains flexibility
 without requiring unnecessary code duplication.
 
-More resources:
+## More resources:
 
 * [Website](http://www.doctrine-project.org)
 * [Documentation](http://www.doctrine-project.org/projects/orm/2.0/docs/reference/introduction/en)
 * [Issue Tracker](http://www.doctrine-project.org/jira/browse/DDC)
-* [Downloads](http://github.com/doctrine/doctrine2/downloads)
+* [Downloads](http://github.com/doctrine/doctrine2/downloads)
+

UPGRADE_TO_2_2

@@ -1,3 +1,17 @@
+# ResultCache implementation rewritten
+
+The result cache is completly rewritten and now works on the database result level, not inside the ORM AbstractQuery
+anymore. This means that for result cached queries the hydration will now always be performed again, regardless of
+the hydration mode. Affected areas are:
+
+1. Fixes the problem that entities coming from the result cache were not registered in the UnitOfWork
+   leading to problems during EntityManager#flush. Calls to EntityManager#merge are not necessary anymore.
+2. Affects the array hydrator which now includes the overhead of hydration compared to caching the final result.
+
+The API is backwards compatible however most of the getter methods on the `AbstractQuery` object are now
+deprecated in favor of calling AbstractQuery#getQueryCacheProfile(). This method returns a `Doctrine\DBAL\Cache\QueryCacheProfile`
+instance with access to result cache driver, lifetime and cache key.
+
 # EntityManager#getPartialReference() creates read-only entity
 
 Entities returned from EntityManager#getPartialReference() are now marked as read-only if they

composer.json

@@ -16,5 +16,8 @@
         "ext-pdo": "*",
         "doctrine/common": "master-dev",
         "doctrine/dbal": "master-dev"
+    },
+    "autoload": {
+        "psr-0": { "Doctrine\\ORM": "lib/" }
     }
 }

lib/Doctrine/ORM/AbstractQuery.php

@@ -20,7 +20,8 @@
 namespace Doctrine\ORM;
 
 use Doctrine\DBAL\Types\Type,
-    Doctrine\ORM\Query\QueryException;
+    Doctrine\ORM\Query\QueryException,
+    Doctrine\DBAL\Cache\QueryCacheProfile;
 
 /**
  * Base contract for ORM queries. Base class for Query and NativeQuery.
@@ -91,34 +92,15 @@ abstract class AbstractQuery
     protected $_hydrationMode = self::HYDRATE_OBJECT;
 
     /**
-     * The locally set cache driver used for caching result sets of this query.
-     *
-     * @var CacheDriver
+     * @param \Doctrine\DBAL\Cache\QueryCacheProfile
      */
-    protected $_resultCacheDriver;
-
-    /**
-     * Boolean flag for whether or not to cache the results of this query.
-     *
-     * @var boolean
-     */
-    protected $_useResultCache;
-
-    /**
-     * @var string The id to store the result cache entry under.
-     */
-    protected $_resultCacheId;
+    protected $_queryCacheProfile;
 
     /**
      * @var boolean Boolean value that indicates whether or not expire the result cache.
      */
     protected $_expireResultCache = false;
 
-    /**
-     * @var int Result Cache lifetime.
-     */
-    protected $_resultCacheTTL;
-
     /**
      * Initializes a new instance of a class derived from <tt>AbstractQuery</tt>.
      *
@@ -260,7 +242,7 @@ abstract class AbstractQuery
     }
 
     /**
-     * Defines a cache driver to be used for caching result sets.
+     * Defines a cache driver to be used for caching result sets and implictly enables caching.
      *
      * @param Doctrine\Common\Cache\Cache $driver Cache driver
      * @return Doctrine\ORM\AbstractQuery
@@ -270,9 +252,10 @@ abstract class AbstractQuery
         if ($resultCacheDriver !== null && ! ($resultCacheDriver instanceof \Doctrine\Common\Cache\Cache)) {
             throw ORMException::invalidResultCacheDriver();
         }
-        $this->_resultCacheDriver = $resultCacheDriver;
-        if ($resultCacheDriver) {
-            $this->_useResultCache = true;
+        if ($this->_queryCacheProfile) {
+            $this->_queryCacheProfile = $this->_queryCacheProfile->setResultCacheDriver($resultCacheDriver);
+        } else {
+            $this->_queryCacheProfile = new QueryCacheProfile(0, null, $resultCacheDriver);
         }
         return $this;
     }
@@ -280,12 +263,13 @@ abstract class AbstractQuery
     /**
      * Returns the cache driver used for caching result sets.
      *
+     * @deprecated
      * @return Doctrine\Common\Cache\Cache Cache driver
      */
     public function getResultCacheDriver()
     {
-        if ($this->_resultCacheDriver) {
-            return $this->_resultCacheDriver;
+        if ($this->_queryCacheProfile && $this->_queryCacheProfile->getResultCacheDriver()) {
+            return $this->_queryCacheProfile->getResultCacheDriver();
         } else {
             return $this->_em->getConfiguration()->getResultCacheImpl();
         }
@@ -296,18 +280,17 @@ abstract class AbstractQuery
      * how long and which ID to use for the cache entry.
      *
      * @param boolean $bool
-     * @param integer $timeToLive
+     * @param integer $lifetime
      * @param string $resultCacheId
      * @return Doctrine\ORM\AbstractQuery This query instance.
      */
-    public function useResultCache($bool, $timeToLive = null, $resultCacheId = null)
+    public function useResultCache($bool, $lifetime = null, $resultCacheId = null)
     {
-        $this->_useResultCache = $bool;
-        if ($timeToLive) {
-            $this->setResultCacheLifetime($timeToLive);
-        }
-        if ($resultCacheId) {
-            $this->_resultCacheId = $resultCacheId;
+        if ($bool) {
+            $this->setResultCacheLifetime($lifetime);
+            $this->setResultCacheId($resultCacheId);
+        } else {
+            $this->_queryCacheProfile = null;
         }
         return $this;
     }
@@ -315,27 +298,33 @@ abstract class AbstractQuery
     /**
      * Defines how long the result cache will be active before expire.
      *
-     * @param integer $timeToLive How long the cache entry is valid.
+     * @param integer $lifetime How long the cache entry is valid.
      * @return Doctrine\ORM\AbstractQuery This query instance.
      */
-    public function setResultCacheLifetime($timeToLive)
+    public function setResultCacheLifetime($lifetime)
     {
-        if ($timeToLive !== null) {
-            $timeToLive = (int) $timeToLive;
+        if ($lifetime === null) {
+            $lifetime = 0;
+        } else {
+            $lifetime = (int)$lifetime;
+        }
+        if ($this->_queryCacheProfile) {
+            $this->_queryCacheProfile = $this->_queryCacheProfile->setLifetime($lifetime);
+        } else {
+            $this->_queryCacheProfile = new QueryCacheProfile($lifetime);
         }
-
-        $this->_resultCacheTTL = $timeToLive;
         return $this;
     }
 
     /**
      * Retrieves the lifetime of resultset cache.
      *
+     * @deprecated
      * @return integer
      */
     public function getResultCacheLifetime()
     {
-        return $this->_resultCacheTTL;
+        return $this->_queryCacheProfile ? $this->_queryCacheProfile->getLifetime() : 0;
     }
 
     /**
@@ -360,6 +349,14 @@ abstract class AbstractQuery
         return $this->_expireResultCache;
     }
 
+    /**
+     * @return QueryCacheProfile
+     */
+    public function getQueryCacheProfile()
+    {
+        return $this->_queryCacheProfile;
+    }
+
     /**
      * Change the default fetch mode of an association for this query.
      *
@@ -548,7 +545,7 @@ abstract class AbstractQuery
      *
      * @param array $params The query parameters.
      * @param integer $hydrationMode The hydration mode to use.
-     * @return IterableResult
+     * @return \Doctrine\ORM\Internal\Hydration\IterableResult
      */
     public function iterate(array $params = array(), $hydrationMode = null)
     {
@@ -584,28 +581,6 @@ abstract class AbstractQuery
             $this->setParameters($params);
         }
 
-        // Check result cache
-        if ($this->_useResultCache && $cacheDriver = $this->getResultCacheDriver()) {
-            list($key, $hash) = $this->getResultCacheId();
-            $cached = $this->_expireResultCache ? false : $cacheDriver->fetch($hash);
-
-            if ($cached === false || !isset($cached[$key])) {
-                // Cache miss.
-                $stmt = $this->_doExecute();
-
-                $result = $this->_em->getHydrator($this->_hydrationMode)->hydrateAll(
-                    $stmt, $this->_resultSetMapping, $this->_hints
-                );
-
-                $cacheDriver->save($hash, array($key => $result), $this->_resultCacheTTL);
-
-                return $result;
-            } else {
-                // Cache hit.
-                return $cached[$key];
-            }
-        }
-
         $stmt = $this->_doExecute();
 
         if (is_numeric($stmt)) {
@@ -627,43 +602,23 @@ abstract class AbstractQuery
      */
     public function setResultCacheId($id)
     {
-        $this->_resultCacheId = $id;
+        if ($this->_queryCacheProfile) {
+            $this->_queryCacheProfile = $this->_queryCacheProfile->setCacheKey($id);
+        } else {
+            $this->_queryCacheProfile = new QueryCacheProfile(0, $id);
+        }
         return $this;
     }
 
     /**
-     * Get the result cache id to use to store the result set cache entry.
-     * Will return the configured id if it exists otherwise a hash will be
-     * automatically generated for you.
+     * Get the result cache id to use to store the result set cache entry if set.
      *
-     * @return array ($key, $hash)
+     * @deprecated
+     * @return string
      */
-    protected function getResultCacheId()
+    public function getResultCacheId()
     {
-        if ($this->_resultCacheId) {
-            return array($this->_resultCacheId, $this->_resultCacheId);
-        } else {
-            $params = $this->_params;
-            foreach ($params AS $key => $value) {
-                if (is_object($value) && $this->_em->getMetadataFactory()->hasMetadataFor(get_class($value))) {
-                    if ($this->_em->getUnitOfWork()->getEntityState($value) == UnitOfWork::STATE_MANAGED) {
-                        $idValues = $this->_em->getUnitOfWork()->getEntityIdentifier($value);
-                    } else {
-                        $class = $this->_em->getClassMetadata(get_class($value));
-                        $idValues = $class->getIdentifierValues($value);
-                    }
-                    $params[$key] = $idValues;
-                } else {
-                    $params[$key] = $value;
-                }
-            }
-
-            $sql = $this->getSql();
-            ksort($this->_hints);
-            $key = implode(";", (array)$sql) . var_export($params, true) .
-                var_export($this->_hints, true)."&hydrationMode=".$this->_hydrationMode;
-            return array($key, md5($key));
-        }
+        return $this->_queryCacheProfile ? $this->_queryCacheProfile->getCacheKey() : null;
     }
 
     /**

lib/Doctrine/ORM/Configuration.php

@@ -209,27 +209,6 @@ class Configuration extends \Doctrine\DBAL\Configuration
                 $this->_attributes['metadataDriverImpl'] : null;
     }
 
-    /**
-     * Gets the cache driver implementation that is used for query result caching.
-     *
-     * @return \Doctrine\Common\Cache\Cache
-     */
-    public function getResultCacheImpl()
-    {
-        return isset($this->_attributes['resultCacheImpl']) ?
-                $this->_attributes['resultCacheImpl'] : null;
-    }
-
-    /**
-     * Sets the cache driver implementation that is used for query result caching.
-     *
-     * @param \Doctrine\Common\Cache\Cache $cacheImpl
-     */
-    public function setResultCacheImpl(Cache $cacheImpl)
-    {
-        $this->_attributes['resultCacheImpl'] = $cacheImpl;
-    }
-
     /**
      * Gets the cache driver implementation that is used for the query cache (SQL cache).
      *

lib/Doctrine/ORM/EntityManager.php

@@ -207,6 +207,7 @@ class EntityManager implements ObjectManager
      * the transaction is rolled back, the EntityManager closed and the exception re-thrown.
      *
      * @param Closure $func The function to execute transactionally.
+     * @return mixed Returns the non-empty value returned from the closure or true instead
      */
     public function transactional(Closure $func)
     {
@@ -333,13 +334,17 @@ class EntityManager implements ObjectManager
      * This effectively synchronizes the in-memory state of managed objects with the
      * database.
      *
+     * If an entity is explicitly passed to this method only this entity and
+     * the cascade-persist semantics + scheduled inserts/removals are synchronized.
+     *
+     * @param object $entity
      * @throws Doctrine\ORM\OptimisticLockException If a version check on an entity that
      *         makes use of optimistic locking fails.
      */
-    public function flush()
+    public function flush($entity = null)
     {
         $this->errorIfClosed();
-        $this->unitOfWork->commit();
+        $this->unitOfWork->commit($entity);
     }
 
     /**

lib/Doctrine/ORM/EntityRepository.php

@@ -225,6 +225,14 @@ class EntityRepository implements ObjectRepository
         return $this->_entityName;
     }
 
+    /**
+     * @return string
+     */
+    public function getClassName()
+    {
+        return $this->getEntityName();
+    }
+
     /**
      * @return EntityManager
      */
@@ -240,4 +248,4 @@ class EntityRepository implements ObjectRepository
     {
         return $this->_class;
     }
-}
+}

lib/Doctrine/ORM/Event/EntityEventDelegator.php

@@ -19,14 +19,16 @@
 
 namespace Doctrine\ORM\Event;
 
-use \Doctrine\Common\EventSubscriber;
-use \LogicException;
+use Doctrine\Common\EventSubscriber;
+use LogicException;
 
 /**
  * Delegate events only for certain entities they are registered for.
  *
- * @author Benjamin Eberlei <kontakt@beberlei.de>
- * @since 2.2
+ * @link    www.doctrine-project.org
+ * @author  Benjamin Eberlei <kontakt@beberlei.de>
+ * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @since   2.2
  */
 class EntityEventDelegator implements EventSubscriber
 {
@@ -54,17 +56,23 @@ class EntityEventDelegator implements EventSubscriber
     public function addEventListener($events, $entities, $listener)
     {
         if ($this->frozen) {
-            throw new LogicException("Cannot add event listeners after EntityEventDelegator::getSubscribedEvents() " .
-                "is called once. This happens when you register the delegator with the event manager.");
+            throw new LogicException(
+                "Cannot add event listeners after EntityEventDelegator::getSubscribedEvents() " .
+                "is called once. This happens when you register the delegator with the event manager."
+            );
         }
 
         // Picks the hash code related to that listener
-        $hash = spl_object_hash($listener);
+        $hash     = spl_object_hash($listener);
+        $entities = array_flip((array) $entities);
 
         foreach ((array) $events as $event) {
             // Overrides listener if a previous one was associated already
             // Prevents duplicate listeners on same event (same instance only)
-            $this->listeners[$event][$hash] = array('listener' => $listener, 'entities' => array_flip((array)$entities));
+            $this->listeners[$event][$hash] = array(
+                'listener' => $listener, 
+                'entities' => $entities
+            );
         }
     }
 
@@ -73,6 +81,7 @@ class EntityEventDelegator implements EventSubscriber
      * interested in and added as a listener for these events.
      *
      * @param Doctrine\Common\EventSubscriber $subscriber The subscriber.
+     * @param array $entities
      */
     public function addEventSubscriber(EventSubscriber $subscriber, $entities)
     {
@@ -87,24 +96,27 @@ class EntityEventDelegator implements EventSubscriber
     public function getSubscribedEvents()
     {
         $this->frozen = true;
+        
         return array_keys($this->listeners);
     }
 
     /**
      * Delegate the event to an appropriate listener
      *
-     * @param $eventName
-     * @param $event
+     * @param string $eventName
+     * @param array $args
      * @return void
      */
     public function __call($eventName, $args)
     {
         $event = $args[0];
+        
         foreach ($this->listeners[$eventName] AS $listenerData) {
             $class = get_class($event->getEntity());
-            if (isset($listenerData['entities'][$class])) {
-                $listenerData['listener']->$eventName($event);
-            }
+            
+            if ( ! isset($listenerData['entities'][$class])) continue;
+            
+            $listenerData['listener']->$eventName($event);
         }
     }
 }

lib/Doctrine/ORM/Event/LifecycleEventArgs.php

@@ -19,42 +19,59 @@
 
 namespace Doctrine\ORM\Event;
 
+use Doctrine\Common\EventArgs;
+use Doctrine\ORM\EntityManager;
+
 /**
  * Lifecycle Events are triggered by the UnitOfWork during lifecycle transitions
  * of entities.
  *
- * @since 2.0
+ * @link   www.doctrine-project.org
+ * @since  2.0
  * @author Roman Borschel <roman@code-factory.de>
  * @author Benjamin Eberlei <kontakt@beberlei.de>
  */
-class LifecycleEventArgs extends \Doctrine\Common\EventArgs
+class LifecycleEventArgs extends EventArgs
 {
     /**
-     * @var EntityManager
+     * @var Doctrine\ORM\EntityManager
      */
-    private $_em;
+    private $em;
 
     /**
      * @var object
      */
-    private $_entity;
+    private $entity;
     
-    public function __construct($entity, $em)
+    /**
+     * Constructor
+     * 
+     * @param object $entity
+     * @param Doctrine\ORM\EntityManager $em 
+     */
+    public function __construct($entity, EntityManager $em)
     {
-        $this->_entity = $entity;
-        $this->_em = $em;
+        $this->entity = $entity;
+        $this->em     = $em;
     }
     
+    /**
+     * Retireve associated Entity.
+     * 
+     * @return object 
+     */
     public function getEntity()
     {
-        return $this->_entity;
+        return $this->entity;
     }
 
     /**
-     * @return EntityManager
+     * Retrieve associated EntityManager.
+     * 
+     * @return Doctrine\ORM\EntityManager
      */
     public function getEntityManager()
     {
-        return $this->_em;
+        return $this->em;
     }
 }

lib/Doctrine/ORM/Event/LoadClassMetadataEventArgs.php

@@ -1,9 +1,25 @@
 <?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
 
 namespace Doctrine\ORM\Event;
 
 use Doctrine\Common\EventArgs;
-
 use Doctrine\ORM\Mapping\ClassMetadataInfo;
 use Doctrine\ORM\EntityManager;
 
@@ -11,32 +27,36 @@ use Doctrine\ORM\EntityManager;
  * Class that holds event arguments for a loadMetadata event.
  *
  * @author Jonathan H. Wage <jonwage@gmail.com>
- * @since 2.0
+ * @since  2.0
  */
 class LoadClassMetadataEventArgs extends EventArgs
 {
     /**
-     * @var ClassMetadata
+     * @var Doctrine\ORM\Mapping\ClassMetadata
      */
     private $classMetadata;
 
     /**
-     * @var EntityManager
+     * @var Doctrine\ORM\EntityManager
      */
     private $em;
 
     /**
-     * @param ClassMetadataInfo $classMetadata
-     * @param EntityManager $em
+     * Constructor.
+     * 
+     * @param Doctrine\ORM\Mapping\ClassMetadataInfo $classMetadata
+     * @param Doctrine\ORM\EntityManager $em
      */
     public function __construct(ClassMetadataInfo $classMetadata, EntityManager $em)
     {
         $this->classMetadata = $classMetadata;
-        $this->em = $em;
+        $this->em            = $em;
     }
 
     /**
-     * @return ClassMetadataInfo
+     * Retrieve associated ClassMetadata.
+     *  
+     * @return Doctrine\ORM\Mapping\ClassMetadataInfo
      */
     public function getClassMetadata()
     {
@@ -44,7 +64,9 @@ class LoadClassMetadataEventArgs extends EventArgs
     }
 
     /**
-     * @return EntityManager
+     * Retrieve associated EntityManager.
+     * 
+     * @return Doctrine\ORM\EntityManager
      */
     public function getEntityManager()
     {

lib/Doctrine/ORM/Event/OnClearEventArgs.php

@@ -15,7 +15,7 @@
  * This software consists of voluntary contributions made by many individuals
  * and is licensed under the LGPL. For more information, see
  * <http://www.doctrine-project.org>.
-*/
+ */
 
 namespace Doctrine\ORM\Event;
 
@@ -23,16 +23,15 @@ namespace Doctrine\ORM\Event;
  * Provides event arguments for the onClear event.
  *
  * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
- * @link        www.doctrine-project.com
+ * @link        www.doctrine-project.org
  * @since       2.0
- * @version     $Revision$
  * @author      Roman Borschel <roman@code-factory.de>
  * @author      Benjamin Eberlei <kontakt@beberlei.de>
  */
 class OnClearEventArgs extends \Doctrine\Common\EventArgs
 {
     /**
-     * @var \Doctrine\ORM\EntityManager
+     * @var Doctrine\ORM\EntityManager
      */
     private $em;
 
@@ -42,16 +41,21 @@ class OnClearEventArgs extends \Doctrine\Common\EventArgs
     private $entityClass;
 
     /**
-     * @param \Doctrine\ORM\EntityManager $em
+     * Constructor.
+     * 
+     * @param Doctrine\ORM\EntityManager $em
+     * @param string $entityClass Optional entity class
      */
     public function __construct($em, $entityClass = null)
     {
-        $this->em = $em;
+        $this->em          = $em;
         $this->entityClass = $entityClass;
     }
 
     /**
-     * @return \Doctrine\ORM\EntityManager
+     * Retrieve associated EntityManager.
+     * 
+     * @return Doctrine\ORM\EntityManager
      */
     public function getEntityManager()
     {
@@ -75,6 +79,6 @@ class OnClearEventArgs extends \Doctrine\Common\EventArgs
      */
     public function clearsAllEntities()
     {
-        return $this->entityClass === null;
+        return ($this->entityClass === null);
     }
 }

lib/Doctrine/ORM/Event/OnFlushEventArgs.php

@@ -21,37 +21,45 @@
 
 namespace Doctrine\ORM\Event;
 
+use Doctrine\ORM\EntityManager;
+
 /**
  * Provides event arguments for the preFlush event.
  *
  * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
- * @link        www.doctrine-project.com
+ * @link        www.doctrine-project.org
  * @since       2.0
- * @version     $Revision$
  * @author      Roman Borschel <roman@code-factory.de>
  * @author      Benjamin Eberlei <kontakt@beberlei.de>
  */
 class OnFlushEventArgs extends \Doctrine\Common\EventArgs
 {
     /**
-     * @var EntityManager
+     * @var Doctirne\ORM\EntityManager
      */
-    private $_em;
+    private $em;
     
-    //private $_entitiesToPersist = array();
-    //private $_entitiesToRemove = array();
+    //private $entitiesToPersist = array();
+    //private $entitiesToRemove = array();
     
-    public function __construct($em)
+    /**
+     * Constructor.
+     * 
+     * @param Doctrine\ORM\EntityManager $em 
+     */
+    public function __construct(EntityManager $em)
     {
-        $this->_em = $em;
+        $this->em = $em;
     }
 
     /**
-     * @return EntityManager
+     * Retrieve associated EntityManager.
+     * 
+     * @return Doctrine\ORM\EntityManager
      */
     public function getEntityManager()
     {
-        return $this->_em;
+        return $this->em;
     }
     
     /*

lib/Doctrine/ORM/Event/PostFlushEventArgs.php

@@ -0,0 +1,61 @@
+<?php
+/*
+ *  $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Event;
+
+use Doctrine\ORM\EntityManager;
+use Doctrine\Common\EventArgs;
+
+/**
+ * Provides event arguments for the postFlush event.
+ *
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        www.doctrine-project.org
+ * @since       2.0
+ * @author      Daniel Freudenberger <df@rebuy.de>
+ */
+class PostFlushEventArgs extends EventArgs
+{
+    /**
+     * @var Doctrine\ORM\EntityManager
+     */
+    private $em;
+
+    /**
+     * Constructor.
+     * 
+     * @param Doctrine\ORM\EntityManager $em
+     */
+    public function __construct(EntityManager $em)
+    {
+        $this->em = $em;
+    }
+
+    /**
+     * Retrieve associated EntityManager.
+     * 
+     * @return Doctrine\ORM\EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->em;
+    }
+}

lib/Doctrine/ORM/Event/PreFlushEventArgs.php

@@ -0,0 +1,53 @@
+<?php
+/*
+ *  $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+*/
+
+namespace Doctrine\ORM\Event;
+
+/**
+ * Provides event arguments for the preFlush event.
+ *
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        www.doctrine-project.com
+ * @since       2.0
+ * @version     $Revision$
+ * @author      Roman Borschel <roman@code-factory.de>
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class PreFlushEventArgs extends \Doctrine\Common\EventArgs
+{
+    /**
+     * @var EntityManager
+     */
+    private $_em;
+
+    public function __construct($em)
+    {
+        $this->_em = $em;
+    }
+
+    /**
+     * @return EntityManager
+     */
+    public function getEntityManager()
+    {
+        return $this->_em;
+    }
+}

lib/Doctrine/ORM/Event/PreUpdateEventArgs.php

@@ -1,4 +1,23 @@
 <?php
+/*
+ *  $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
 
 namespace Doctrine\ORM\Event;
 
@@ -8,42 +27,50 @@ use Doctrine\Common\EventArgs,
 /**
  * Class that holds event arguments for a preInsert/preUpdate event.
  *
+ * @author Guilherme Blanco <guilehrmeblanco@hotmail.com>
  * @author Roman Borschel <roman@code-factory.org>
  * @author Benjamin Eberlei <kontakt@beberlei.de>
- * @since 2.0
+ * @since  2.0
  */
 class PreUpdateEventArgs extends LifecycleEventArgs
 {
     /**
      * @var array
      */
-    private $_entityChangeSet;
+    private $entityChangeSet;
 
     /**
-     *
+     * Constructor.
+     * 
      * @param object $entity
-     * @param EntityManager $em
+     * @param Doctrine\ORM\EntityManager $em
      * @param array $changeSet
      */
-    public function __construct($entity, $em, array &$changeSet)
+    public function __construct($entity, EntityManager $em, array &$changeSet)
     {
         parent::__construct($entity, $em);
-        $this->_entityChangeSet = &$changeSet;
-    }
-
-    public function getEntityChangeSet()
-    {
-        return $this->_entityChangeSet;
+        
+        $this->entityChangeSet = &$changeSet;
     }
 
     /**
-     * Field has a changeset?
+     * Retrieve entity changeset.
+     * 
+     * @return array
+     */
+    public function getEntityChangeSet()
+    {
+        return $this->entityChangeSet;
+    }
+
+    /**
+     * Check if field has a changeset.
      *
-     * @return bool
+     * @return boolean
      */
     public function hasChangedField($field)
     {
-        return isset($this->_entityChangeSet[$field]);
+        return isset($this->entityChangeSet[$field]);
     }
 
     /**
@@ -54,9 +81,9 @@ class PreUpdateEventArgs extends LifecycleEventArgs
      */
     public function getOldValue($field)
     {
-    	$this->_assertValidField($field);
+    	$this->assertValidField($field);
 
-        return $this->_entityChangeSet[$field][0];
+        return $this->entityChangeSet[$field][0];
     }
 
     /**
@@ -67,9 +94,9 @@ class PreUpdateEventArgs extends LifecycleEventArgs
      */
     public function getNewValue($field)
     {
-        $this->_assertValidField($field);
+        $this->assertValidField($field);
 
-        return $this->_entityChangeSet[$field][1];
+        return $this->entityChangeSet[$field][1];
     }
 
     /**
@@ -80,18 +107,24 @@ class PreUpdateEventArgs extends LifecycleEventArgs
      */
     public function setNewValue($field, $value)
     {
-        $this->_assertValidField($field);
+        $this->assertValidField($field);
 
-        $this->_entityChangeSet[$field][1] = $value;
+        $this->entityChangeSet[$field][1] = $value;
     }
 
-    private function _assertValidField($field)
+    /**
+     * Assert the field exists in changeset.
+     * 
+     * @param string $field 
+     */
+    private function assertValidField($field)
     {
-    	if (!isset($this->_entityChangeSet[$field])) {
-            throw new \InvalidArgumentException(
-                "Field '".$field."' is not a valid field of the entity ".
-                "'".get_class($this->getEntity())."' in PreUpdateEventArgs."
-            );
+    	if ( ! isset($this->entityChangeSet[$field])) {
+            throw new \InvalidArgumentException(sprintf(
+                'Field "%s" is not a valid field of the entity "%s" in PreUpdateEventArgs.',
+                $field,
+                get_class($this->getEntity())
+            ));
         }
     }
 }

lib/Doctrine/ORM/Events.php

@@ -109,6 +109,13 @@ final class Events
      */
     const loadClassMetadata = 'loadClassMetadata';
     
+    /**
+     * The preFlush event occurs when the EntityManager#flush() operation is invoked,
+     * but before any changes to managed entites have been calculated. This event is
+     * always raised right after EntityManager#flush() call.
+     */
+    const preFlush = 'preFlush';
+
     /**
      * The onFlush event occurs when the EntityManager#flush() operation is invoked,
      * after any changes to managed entities have been determined but before any
@@ -120,6 +127,17 @@ final class Events
      */
     const onFlush = 'onFlush';
 
+    /**
+     * The postFlush event occurs when the EntityManager#flush() operation is invoked and
+     * after all actual database operations are executed successfully. The event is only raised if there is
+     * actually something to do for the underlying UnitOfWork. If nothing needs to be done,
+     * the postFlush event is not raised. The event won't be raised if an error occurs during the
+     * flush operation.
+     * 
+     * @var string
+     */
+    const postFlush = 'postFlush';
+    
     /**
      * The onClear event occurs when the EntityManager#clear() operation is invoked,
      * after all references to entities have been removed from the unit of work.

lib/Doctrine/ORM/Id/AssignedGenerator.php

@@ -20,6 +20,7 @@
 namespace Doctrine\ORM\Id;
 
 use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\ORMException;
 
 /**
@@ -42,46 +43,29 @@ class AssignedGenerator extends AbstractIdGenerator
      */
     public function generate(EntityManager $em, $entity)
     {
-        $class = $em->getClassMetadata(get_class($entity));
+        $class      = $em->getClassMetadata(get_class($entity));
+        $idFields   = $class->getIdentifierFieldNames();
         $identifier = array();
-        if ($class->isIdentifierComposite) {
-            $idFields = $class->getIdentifierFieldNames();
-            foreach ($idFields as $idField) {
-                $value = $class->reflFields[$idField]->getValue($entity);
-                if (isset($value)) {
-                    if (isset($class->associationMappings[$idField])) {
-                        if (!$em->getUnitOfWork()->isInIdentityMap($value)) {
-                            throw ORMException::entityMissingForeignAssignedId($entity, $value);
-                        }
-
-                        // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced.
-                        $identifier[$idField] = current($em->getUnitOfWork()->getEntityIdentifier($value));
-                    } else {
-                        $identifier[$idField] = $value;
-                    }
-                } else {
-                    throw ORMException::entityMissingAssignedIdForField($entity, $idField);
-                }
-            }
-        } else {
-            $idField = $class->identifier[0];
+        
+        foreach ($idFields as $idField) {
             $value = $class->reflFields[$idField]->getValue($entity);
-            if (isset($value)) {
-                if (isset($class->associationMappings[$idField])) {
-                    if (!$em->getUnitOfWork()->isInIdentityMap($value)) {
-                        throw ORMException::entityMissingForeignAssignedId($entity, $value);
-                    }
-
-                    // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced.
-                    $identifier[$idField] = current($em->getUnitOfWork()->getEntityIdentifier($value));
-                } else {
-                    $identifier[$idField] = $value;
-                }
-            } else {
+            
+            if ( ! isset($value)) {
                 throw ORMException::entityMissingAssignedIdForField($entity, $idField);
             }
-        }
+            
+            if (isset($class->associationMappings[$idField])) {
+                if ( ! $em->getUnitOfWork()->isInIdentityMap($value)) {
+                    throw ORMException::entityMissingForeignAssignedId($entity, $value);
+                }
 
+                // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced.
+                $value = current($em->getUnitOfWork()->getEntityIdentifier($value));
+            }
+            
+            $identifier[$idField] = $value;
+        }
+        
         return $identifier;
     }
 }

lib/Doctrine/ORM/Id/IdentityGenerator.php

@@ -46,7 +46,7 @@ class IdentityGenerator extends AbstractIdGenerator
      */
     public function generate(EntityManager $em, $entity)
     {
-        return $em->getConnection()->lastInsertId($this->_seqName);
+        return (int)$em->getConnection()->lastInsertId($this->_seqName);
     }
 
     /**

lib/Doctrine/ORM/Id/SequenceGenerator.php

@@ -46,7 +46,7 @@ class SequenceGenerator extends AbstractIdGenerator implements Serializable
         $this->_sequenceName = $sequenceName;
         $this->_allocationSize = $allocationSize;
     }
-    
+
     /**
      * Generates an ID for the given entity.
      *
@@ -59,10 +59,12 @@ class SequenceGenerator extends AbstractIdGenerator implements Serializable
         if ($this->_maxValue === null || $this->_nextValue == $this->_maxValue) {
             // Allocate new values
             $conn = $em->getConnection();
-            $sql = $conn->getDatabasePlatform()->getSequenceNextValSQL($this->_sequenceName);
-            $this->_nextValue = $conn->fetchColumn($sql);
-            $this->_maxValue = $this->_nextValue + $this->_allocationSize;
+            $sql  = $conn->getDatabasePlatform()->getSequenceNextValSQL($this->_sequenceName);
+
+            $this->_nextValue = (int)$conn->fetchColumn($sql);
+            $this->_maxValue  = $this->_nextValue + $this->_allocationSize;
         }
+
         return $this->_nextValue++;
     }
 
@@ -90,13 +92,14 @@ class SequenceGenerator extends AbstractIdGenerator implements Serializable
     {
         return serialize(array(
             'allocationSize' => $this->_allocationSize,
-            'sequenceName' => $this->_sequenceName
+            'sequenceName'   => $this->_sequenceName
         ));
     }
 
     public function unserialize($serialized)
     {
         $array = unserialize($serialized);
+
         $this->_sequenceName = $array['sequenceName'];
         $this->_allocationSize = $array['allocationSize'];
     }

lib/Doctrine/ORM/Id/TableGenerator.php

@@ -50,11 +50,12 @@ class TableGenerator extends AbstractIdGenerator
         if ($this->_maxValue === null || $this->_nextValue == $this->_maxValue) {
             // Allocate new values
             $conn = $em->getConnection();
-            if ($conn->getTransactionNestingLevel() == 0) {
-
+            
+            if ($conn->getTransactionNestingLevel() === 0) {
                 // use select for update
-                $sql = $conn->getDatabasePlatform()->getTableHiLoCurrentValSql($this->_tableName, $this->_sequenceName);
+                $sql          = $conn->getDatabasePlatform()->getTableHiLoCurrentValSql($this->_tableName, $this->_sequenceName);
                 $currentLevel = $conn->fetchColumn($sql);
+                
                 if ($currentLevel != null) {
                     $this->_nextValue = $currentLevel;
                     $this->_maxValue = $this->_nextValue + $this->_allocationSize;
@@ -74,6 +75,7 @@ class TableGenerator extends AbstractIdGenerator
                 // or do we want to work with table locks exclusively?
             }
         }
+        
         return $this->_nextValue++;
     }
 }

lib/Doctrine/ORM/Internal/Hydration/AbstractHydrator.php

@@ -22,15 +22,17 @@ namespace Doctrine\ORM\Internal\Hydration;
 use PDO,
     Doctrine\DBAL\Connection,
     Doctrine\DBAL\Types\Type,
-    Doctrine\ORM\EntityManager;
+    Doctrine\ORM\EntityManager,
+    Doctrine\ORM\Mapping\ClassMetadata;
 
 /**
  * Base class for all hydrators. A hydrator is a class that provides some form
  * of transformation of an SQL result set into another structure.
  *
- * @since       2.0
- * @author      Konsta Vesterinen <kvesteri@cc.hut.fi>
- * @author      Roman Borschel <roman@code-factory.org>
+ * @since  2.0
+ * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Guilherme Blanco <guilhermeblanoc@hotmail.com>
  */
 abstract class AbstractHydrator
 {
@@ -62,9 +64,9 @@ abstract class AbstractHydrator
      */
     public function __construct(EntityManager $em)
     {
-        $this->_em = $em;
+        $this->_em       = $em;
         $this->_platform = $em->getConnection()->getDatabasePlatform();
-        $this->_uow = $em->getUnitOfWork();
+        $this->_uow      = $em->getUnitOfWork();
     }
 
     /**
@@ -72,14 +74,17 @@ abstract class AbstractHydrator
      *
      * @param object $stmt
      * @param object $resultSetMapping
+     *
      * @return IterableResult
      */
     public function iterate($stmt, $resultSetMapping, array $hints = array())
     {
-        $this->_stmt = $stmt;
-        $this->_rsm = $resultSetMapping;
+        $this->_stmt  = $stmt;
+        $this->_rsm   = $resultSetMapping;
         $this->_hints = $hints;
-        $this->_prepare();
+
+        $this->prepare();
+
         return new IterableResult($this);
     }
 
@@ -92,12 +97,16 @@ abstract class AbstractHydrator
      */
     public function hydrateAll($stmt, $resultSetMapping, array $hints = array())
     {
-        $this->_stmt = $stmt;
-        $this->_rsm = $resultSetMapping;
+        $this->_stmt  = $stmt;
+        $this->_rsm   = $resultSetMapping;
         $this->_hints = $hints;
-        $this->_prepare();
-        $result = $this->_hydrateAll();
-        $this->_cleanup();
+
+        $this->prepare();
+
+        $result = $this->hydrateAllData();
+
+        $this->cleanup();
+
         return $result;
     }
 
@@ -110,12 +119,17 @@ abstract class AbstractHydrator
     public function hydrateRow()
     {
         $row = $this->_stmt->fetch(PDO::FETCH_ASSOC);
+
         if ( ! $row) {
-            $this->_cleanup();
+            $this->cleanup();
+
             return false;
         }
+
         $result = array();
-        $this->_hydrateRow($row, $this->_cache, $result);
+
+        $this->hydrateRowData($row, $this->_cache, $result);
+
         return $result;
     }
 
@@ -123,16 +137,17 @@ abstract class AbstractHydrator
      * Excutes one-time preparation tasks, once each time hydration is started
      * through {@link hydrateAll} or {@link iterate()}.
      */
-    protected function _prepare()
+    protected function prepare()
     {}
 
     /**
      * Excutes one-time cleanup tasks at the end of a hydration that was initiated
      * through {@link hydrateAll} or {@link iterate()}.
      */
-    protected function _cleanup()
+    protected function cleanup()
     {
         $this->_rsm = null;
+
         $this->_stmt->closeCursor();
         $this->_stmt = null;
     }
@@ -146,23 +161,24 @@ abstract class AbstractHydrator
      * @param array $cache The cache to use.
      * @param mixed $result The result to fill.
      */
-    protected function _hydrateRow(array $data, array &$cache, array &$result)
+    protected function hydrateRowData(array $data, array &$cache, array &$result)
     {
-        throw new HydrationException("_hydrateRow() not implemented by this hydrator.");
+        throw new HydrationException("hydrateRowData() not implemented by this hydrator.");
     }
 
     /**
      * Hydrates all rows from the current statement instance at once.
      */
-    abstract protected function _hydrateAll();
+    abstract protected function hydrateAllData();
 
     /**
      * Processes a row of the result set.
+     *
      * Used for identity-based hydration (HYDRATE_OBJECT and HYDRATE_ARRAY).
-     * Puts the elements of a result row into a new array, grouped by the class
+     * Puts the elements of a result row into a new array, grouped by the dql alias
      * they belong to. The column names in the result set are mapped to their
      * field names during this procedure as well as any necessary conversions on
-     * the values applied.
+     * the values applied. Scalar values are kept in a specfic key 'scalars'.
      *
      * @param array $data SQL Result Row
      * @param array &$cache Cache for column to field result information
@@ -172,40 +188,51 @@ abstract class AbstractHydrator
      * @return array  An array with all the fields (name => value) of the data row,
      *                grouped by their component alias.
      */
-    protected function _gatherRowData(array $data, array &$cache, array &$id, array &$nonemptyComponents)
+    protected function gatherRowData(array $data, array &$cache, array &$id, array &$nonemptyComponents)
     {
         $rowData = array();
 
         foreach ($data as $key => $value) {
             // Parse each column name only once. Cache the results.
             if ( ! isset($cache[$key])) {
-                if (isset($this->_rsm->scalarMappings[$key])) {
-                    $cache[$key]['fieldName'] = $this->_rsm->scalarMappings[$key];
-                    $cache[$key]['isScalar'] = true;
-                } else if (isset($this->_rsm->fieldMappings[$key])) {
-                    $fieldName = $this->_rsm->fieldMappings[$key];
-                    $classMetadata = $this->_em->getClassMetadata($this->_rsm->declaringClasses[$key]);
-                    $cache[$key]['fieldName'] = $fieldName;
-                    $cache[$key]['type'] = Type::getType($classMetadata->fieldMappings[$fieldName]['type']);
-                    $cache[$key]['isIdentifier'] = $classMetadata->isIdentifier($fieldName);
-                    $cache[$key]['dqlAlias'] = $this->_rsm->columnOwnerMap[$key];
-                } else if (!isset($this->_rsm->metaMappings[$key])) {
-                    // this column is a left over, maybe from a LIMIT query hack for example in Oracle or DB2
-                    // maybe from an additional column that has not been defined in a NativeQuery ResultSetMapping.
-                    continue;
-                } else {
-                    // Meta column (has meaning in relational schema only, i.e. foreign keys or discriminator columns).
-                    $fieldName = $this->_rsm->metaMappings[$key];
-                    $cache[$key]['isMetaColumn'] = true;
-                    $cache[$key]['fieldName'] = $fieldName;
-                    $cache[$key]['dqlAlias'] = $this->_rsm->columnOwnerMap[$key];
-                    $classMetadata = $this->_em->getClassMetadata($this->_rsm->aliasMap[$cache[$key]['dqlAlias']]);
-                    $cache[$key]['isIdentifier'] = isset($this->_rsm->isIdentifierColumn[$cache[$key]['dqlAlias']][$key]);
+                switch (true) {
+                    // NOTE: Most of the times it's a field mapping, so keep it first!!!
+                    case (isset($this->_rsm->fieldMappings[$key])):
+                        $fieldName     = $this->_rsm->fieldMappings[$key];
+                        $classMetadata = $this->_em->getClassMetadata($this->_rsm->declaringClasses[$key]);
+
+                        $cache[$key]['fieldName']    = $fieldName;
+                        $cache[$key]['type']         = Type::getType($classMetadata->fieldMappings[$fieldName]['type']);
+                        $cache[$key]['isIdentifier'] = $classMetadata->isIdentifier($fieldName);
+                        $cache[$key]['dqlAlias']     = $this->_rsm->columnOwnerMap[$key];
+                        break;
+
+                    case (isset($this->_rsm->scalarMappings[$key])):
+                        $cache[$key]['fieldName'] = $this->_rsm->scalarMappings[$key];
+                        $cache[$key]['isScalar']  = true;
+                        break;
+
+                    case (isset($this->_rsm->metaMappings[$key])):
+                        // Meta column (has meaning in relational schema only, i.e. foreign keys or discriminator columns).
+                        $fieldName     = $this->_rsm->metaMappings[$key];
+                        $classMetadata = $this->_em->getClassMetadata($this->_rsm->aliasMap[$this->_rsm->columnOwnerMap[$key]]);
+
+                        $cache[$key]['isMetaColumn'] = true;
+                        $cache[$key]['fieldName']    = $fieldName;
+                        $cache[$key]['dqlAlias']     = $this->_rsm->columnOwnerMap[$key];
+                        $cache[$key]['isIdentifier'] = isset($this->_rsm->isIdentifierColumn[$cache[$key]['dqlAlias']][$key]);
+                        break;
+
+                    default:
+                        // this column is a left over, maybe from a LIMIT query hack for example in Oracle or DB2
+                        // maybe from an additional column that has not been defined in a NativeQuery ResultSetMapping.
+                        continue 2;
                 }
             }
-            
+
             if (isset($cache[$key]['isScalar'])) {
                 $rowData['scalars'][$cache[$key]['fieldName']] = $value;
+
                 continue;
             }
 
@@ -216,13 +243,14 @@ abstract class AbstractHydrator
             }
 
             if (isset($cache[$key]['isMetaColumn'])) {
-                if (!isset($rowData[$dqlAlias][$cache[$key]['fieldName']]) || $value !== null) {
+                if ( ! isset($rowData[$dqlAlias][$cache[$key]['fieldName']]) || $value !== null) {
                     $rowData[$dqlAlias][$cache[$key]['fieldName']] = $value;
                 }
+
                 continue;
             }
-            
-            // in an inheritance hierachy the same field could be defined several times.
+
+            // in an inheritance hierarchy the same field could be defined several times.
             // We overwrite this value so long we dont have a non-null value, that value we keep.
             // Per definition it cannot be that a field is defined several times and has several values.
             if (isset($rowData[$dqlAlias][$cache[$key]['fieldName']]) && $value === null) {
@@ -241,6 +269,7 @@ abstract class AbstractHydrator
 
     /**
      * Processes a row of the result set.
+     *
      * Used for HYDRATE_SCALAR. This is a variant of _gatherRowData() that
      * simply converts column names to field names and properly converts the
      * values according to their types. The resulting row has the same number
@@ -248,52 +277,77 @@ abstract class AbstractHydrator
      *
      * @param array $data
      * @param array $cache
+     *
      * @return array The processed row.
      */
-    protected function _gatherScalarRowData(&$data, &$cache)
+    protected function gatherScalarRowData(&$data, &$cache)
     {
         $rowData = array();
 
         foreach ($data as $key => $value) {
             // Parse each column name only once. Cache the results.
             if ( ! isset($cache[$key])) {
-                if (isset($this->_rsm->scalarMappings[$key])) {
-                    $cache[$key]['fieldName'] = $this->_rsm->scalarMappings[$key];
-                    $cache[$key]['isScalar'] = true;
-                } else if (isset($this->_rsm->fieldMappings[$key])) {
-                    $fieldName = $this->_rsm->fieldMappings[$key];
-                    $classMetadata = $this->_em->getClassMetadata($this->_rsm->declaringClasses[$key]);
-                    $cache[$key]['fieldName'] = $fieldName;
-                    $cache[$key]['type'] = Type::getType($classMetadata->fieldMappings[$fieldName]['type']);
-                    $cache[$key]['dqlAlias'] = $this->_rsm->columnOwnerMap[$key];
-                } else if (!isset($this->_rsm->metaMappings[$key])) {
-                    // this column is a left over, maybe from a LIMIT query hack for example in Oracle or DB2
-                    // maybe from an additional column that has not been defined in a NativeQuery ResultSetMapping.
-                    continue;
-                } else {
-                    // Meta column (has meaning in relational schema only, i.e. foreign keys or discriminator columns).
-                    $cache[$key]['isMetaColumn'] = true;
-                    $cache[$key]['fieldName'] = $this->_rsm->metaMappings[$key];
-                    $cache[$key]['dqlAlias'] = $this->_rsm->columnOwnerMap[$key];
+                switch (true) {
+                    // NOTE: During scalar hydration, most of the times it's a scalar mapping, keep it first!!!
+                    case (isset($this->_rsm->scalarMappings[$key])):
+                        $cache[$key]['fieldName'] = $this->_rsm->scalarMappings[$key];
+                        $cache[$key]['isScalar']  = true;
+                        break;
+
+                    case (isset($this->_rsm->fieldMappings[$key])):
+                        $fieldName     = $this->_rsm->fieldMappings[$key];
+                        $classMetadata = $this->_em->getClassMetadata($this->_rsm->declaringClasses[$key]);
+
+                        $cache[$key]['fieldName'] = $fieldName;
+                        $cache[$key]['type']      = Type::getType($classMetadata->fieldMappings[$fieldName]['type']);
+                        $cache[$key]['dqlAlias']  = $this->_rsm->columnOwnerMap[$key];
+                        break;
+
+                    case (isset($this->_rsm->metaMappings[$key])):
+                        // Meta column (has meaning in relational schema only, i.e. foreign keys or discriminator columns).
+                        $cache[$key]['isMetaColumn'] = true;
+                        $cache[$key]['fieldName']    = $this->_rsm->metaMappings[$key];
+                        $cache[$key]['dqlAlias']     = $this->_rsm->columnOwnerMap[$key];
+                        break;
+
+                    default:
+                        // this column is a left over, maybe from a LIMIT query hack for example in Oracle or DB2
+                        // maybe from an additional column that has not been defined in a NativeQuery ResultSetMapping.
+                        continue 2;
                 }
             }
-            
+
             $fieldName = $cache[$key]['fieldName'];
 
-            if (isset($cache[$key]['isScalar'])) {
-                $rowData[$fieldName] = $value;
-            } else if (isset($cache[$key]['isMetaColumn'])) {
-                $rowData[$cache[$key]['dqlAlias'] . '_' . $fieldName] = $value;
-            } else {
-                $rowData[$cache[$key]['dqlAlias'] . '_' . $fieldName] = $cache[$key]['type']
-                        ->convertToPHPValue($value, $this->_platform);
+            switch (true) {
+                case (isset($cache[$key]['isScalar'])):
+                    $rowData[$fieldName] = $value;
+                    break;
+
+                case (isset($cache[$key]['isMetaColumn'])):
+                    $rowData[$cache[$key]['dqlAlias'] . '_' . $fieldName] = $value;
+                    break;
+
+                default:
+                    $value = $cache[$key]['type']->convertToPHPValue($value, $this->_platform);
+
+                    $rowData[$cache[$key]['dqlAlias'] . '_' . $fieldName] = $value;
             }
         }
 
         return $rowData;
     }
-    
-    protected function registerManaged($class, $entity, $data)
+
+    /**
+     * Register entity as managed in UnitOfWork.
+     *
+     * @param Doctrine\ORM\Mapping\ClassMetadata $class
+     * @param object $entity
+     * @param array $data
+     *
+     * @todo The "$id" generation is the same of UnitOfWork#createEntity. Remove this duplication somehow
+     */
+    protected function registerManaged(ClassMetadata $class, $entity, array $data)
     {
         if ($class->isIdentifierComposite) {
             $id = array();
@@ -311,6 +365,7 @@ abstract class AbstractHydrator
                 $id = array($class->identifier[0] => $data[$class->identifier[0]]);
             }
         }
+
         $this->_em->getUnitOfWork()->registerManaged($entity, $id, $data);
     }
 }

lib/Doctrine/ORM/Internal/Hydration/ArrayHydrator.php

@@ -25,8 +25,14 @@ use PDO, Doctrine\DBAL\Connection, Doctrine\ORM\Mapping\ClassMetadata;
  * The ArrayHydrator produces a nested array "graph" that is often (not always)
  * interchangeable with the corresponding object graph for read-only access.
  *
+ * @since  2.0
  * @author Roman Borschel <roman@code-factory.org>
- * @since 1.0
+ * @author Guilherme Blanco <guilhermeblanoc@hotmail.com>
+ *
+ * @todo General behavior is "wrong" if you define an alias to selected IdentificationVariable.
+ * Example: SELECT u AS user FROM User u
+ * The result should contains an array where each array index is an array: array('user' => [User object])
+ * Problem must be solved somehow by removing the isMixed in ResultSetMapping
  */
 class ArrayHydrator extends AbstractHydrator
 {
@@ -38,45 +44,55 @@ class ArrayHydrator extends AbstractHydrator
     private $_idTemplate = array();
     private $_resultCounter = 0;
 
-    /** @override */
-    protected function _prepare()
+    /**
+     * {@inheritdoc}
+     */
+    protected function prepare()
     {
-        $this->_isSimpleQuery = count($this->_rsm->aliasMap) <= 1;
-        $this->_identifierMap = array();
+        $this->_isSimpleQuery  = count($this->_rsm->aliasMap) <= 1;
+        $this->_identifierMap  = array();
         $this->_resultPointers = array();
-        $this->_idTemplate = array();
-        $this->_resultCounter = 0;
+        $this->_idTemplate     = array();
+        $this->_resultCounter  = 0;
+
         foreach ($this->_rsm->aliasMap as $dqlAlias => $className) {
-            $this->_identifierMap[$dqlAlias] = array();
+            $this->_identifierMap[$dqlAlias]  = array();
             $this->_resultPointers[$dqlAlias] = array();
-            $this->_idTemplate[$dqlAlias] = '';
+            $this->_idTemplate[$dqlAlias]     = '';
         }
     }
 
-    /** @override */
-    protected function _hydrateAll()
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateAllData()
     {
         $result = array();
-        $cache = array();
+        $cache  = array();
+
         while ($data = $this->_stmt->fetch(PDO::FETCH_ASSOC)) {
-            $this->_hydrateRow($data, $cache, $result);
+            $this->hydrateRowData($data, $cache, $result);
         }
 
         return $result;
     }
 
-    /** @override */
-    protected function _hydrateRow(array $data, array &$cache, array &$result)
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateRowData(array $row, array &$cache, array &$result)
     {
         // 1) Initialize
         $id = $this->_idTemplate; // initialize the id-memory
         $nonemptyComponents = array();
-        $rowData = $this->_gatherRowData($data, $cache, $id, $nonemptyComponents);
+        $rowData = $this->gatherRowData($row, $cache, $id, $nonemptyComponents);
 
         // Extract scalar values. They're appended at the end.
         if (isset($rowData['scalars'])) {
             $scalars = $rowData['scalars'];
+
             unset($rowData['scalars']);
+
             if (empty($rowData)) {
                 ++$this->_resultCounter;
             }
@@ -90,7 +106,7 @@ class ArrayHydrator extends AbstractHydrator
                 // It's a joined result
 
                 $parent = $this->_rsm->parentAliasMap[$dqlAlias];
-                $path = $parent . '.' . $dqlAlias;
+                $path   = $parent . '.' . $dqlAlias;
 
                 // missing parent data, skipping as RIGHT JOIN hydration is not supported.
                 if ( ! isset($nonemptyComponents[$parent]) ) {
@@ -109,39 +125,41 @@ class ArrayHydrator extends AbstractHydrator
                     unset($this->_resultPointers[$dqlAlias]); // Ticket #1228
                     continue;
                 }
-                
+
                 $relationAlias = $this->_rsm->relationMap[$dqlAlias];
-                $relation = $this->_getClassMetadata($this->_rsm->aliasMap[$parent])->associationMappings[$relationAlias];
+                $relation = $this->getClassMetadata($this->_rsm->aliasMap[$parent])->associationMappings[$relationAlias];
 
                 // Check the type of the relation (many or single-valued)
                 if ( ! ($relation['type'] & ClassMetadata::TO_ONE)) {
                     $oneToOne = false;
+
                     if (isset($nonemptyComponents[$dqlAlias])) {
                         if ( ! isset($baseElement[$relationAlias])) {
                             $baseElement[$relationAlias] = array();
                         }
-                        
-                        $indexExists = isset($this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]]);
-                        $index = $indexExists ? $this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]] : false;
+
+                        $indexExists  = isset($this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]]);
+                        $index        = $indexExists ? $this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]] : false;
                         $indexIsValid = $index !== false ? isset($baseElement[$relationAlias][$index]) : false;
-                        
+
                         if ( ! $indexExists || ! $indexIsValid) {
                             $element = $data;
                             if (isset($this->_rsm->indexByMap[$dqlAlias])) {
-                                $field = $this->_rsm->indexByMap[$dqlAlias];
-                                $baseElement[$relationAlias][$element[$field]] = $element;
+                                $baseElement[$relationAlias][$row[$this->_rsm->indexByMap[$dqlAlias]]] = $element;
                             } else {
                                 $baseElement[$relationAlias][] = $element;
                             }
+
                             end($baseElement[$relationAlias]);
-                            $this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]] =
-                                    key($baseElement[$relationAlias]);
+
+                            $this->_identifierMap[$path][$id[$parent]][$id[$dqlAlias]] = key($baseElement[$relationAlias]);
                         }
                     } else if ( ! isset($baseElement[$relationAlias])) {
                         $baseElement[$relationAlias] = array();
                     }
                 } else {
                     $oneToOne = true;
+
                     if ( ! isset($nonemptyComponents[$dqlAlias]) && ! isset($baseElement[$relationAlias])) {
                         $baseElement[$relationAlias] = null;
                     } else if ( ! isset($baseElement[$relationAlias])) {
@@ -157,43 +175,42 @@ class ArrayHydrator extends AbstractHydrator
 
             } else {
                 // It's a root result element
-                
+
                 $this->_rootAliases[$dqlAlias] = true; // Mark as root
+                $entityKey = $this->_rsm->entityMappings[$dqlAlias] ?: 0;
 
                 // if this row has a NULL value for the root result id then make it a null result.
                 if ( ! isset($nonemptyComponents[$dqlAlias]) ) {
                     if ($this->_rsm->isMixed) {
-                        $result[] = array(0 => null);
+                        $result[] = array($entityKey => null);
                     } else {
                         $result[] = null;
                     }
+                    $resultKey = $this->_resultCounter;
                     ++$this->_resultCounter;
                     continue;
                 }
-                
+
                 // Check for an existing element
                 if ($this->_isSimpleQuery || ! isset($this->_identifierMap[$dqlAlias][$id[$dqlAlias]])) {
                     $element = $rowData[$dqlAlias];
-                    if (isset($this->_rsm->indexByMap[$dqlAlias])) {
-                        $field = $this->_rsm->indexByMap[$dqlAlias];
-                        if ($this->_rsm->isMixed) {
-                            $result[] = array($element[$field] => $element);
-                            ++$this->_resultCounter;
-                        } else {
-                            $result[$element[$field]] = $element;
-                        }
-                    } else {
-                        if ($this->_rsm->isMixed) {
-                            $result[] = array($element);
-                            ++$this->_resultCounter;
-                        } else {
-                            $result[] = $element;
-                        }
+                    if ($this->_rsm->isMixed) {
+                        $element = array($entityKey => $element);
                     }
-                    end($result);
-                    $this->_identifierMap[$dqlAlias][$id[$dqlAlias]] = key($result);
+
+                    if (isset($this->_rsm->indexByMap[$dqlAlias])) {
+                        $resultKey = $row[$this->_rsm->indexByMap[$dqlAlias]];
+                        $result[$resultKey] = $element;
+                    } else {
+                        $resultKey = $this->_resultCounter;
+                        $result[] = $element;
+                        ++$this->_resultCounter;
+                    }
+
+                    $this->_identifierMap[$dqlAlias][$id[$dqlAlias]] = $resultKey;
                 } else {
                     $index = $this->_identifierMap[$dqlAlias][$id[$dqlAlias]];
+                    $resultKey = $index;
                     /*if ($this->_rsm->isMixed) {
                         $result[] =& $result[$index];
                         ++$this->_resultCounter;
@@ -205,8 +222,17 @@ class ArrayHydrator extends AbstractHydrator
 
         // Append scalar values to mixed result sets
         if (isset($scalars)) {
+            if ( ! isset($resultKey) ) {
+                // this only ever happens when no object is fetched (scalar result only)
+                if (isset($this->_rsm->indexByMap['scalars'])) {
+                    $resultKey = $row[$this->_rsm->indexByMap['scalars']];
+                } else {
+                    $resultKey = $this->_resultCounter - 1;
+                }
+            }
+
             foreach ($scalars as $name => $value) {
-                $result[$this->_resultCounter - 1][$name] = $value;
+                $result[$resultKey][$name] = $value;
             }
         }
     }
@@ -224,28 +250,45 @@ class ArrayHydrator extends AbstractHydrator
     {
         if ($coll === null) {
             unset($this->_resultPointers[$dqlAlias]); // Ticket #1228
+
             return;
         }
+
         if ($index !== false) {
             $this->_resultPointers[$dqlAlias] =& $coll[$index];
+
             return;
-        } else {
-            if ($coll) {
-                if ($oneToOne) {
-                    $this->_resultPointers[$dqlAlias] =& $coll;
-                } else {
-                    end($coll);
-                    $this->_resultPointers[$dqlAlias] =& $coll[key($coll)];
-                }
-            }
         }
+
+        if ( ! $coll) {
+            return;
+        }
+
+        if ($oneToOne) {
+            $this->_resultPointers[$dqlAlias] =& $coll;
+
+            return;
+        }
+
+        end($coll);
+        $this->_resultPointers[$dqlAlias] =& $coll[key($coll)];
+
+        return;
     }
-    
-    private function _getClassMetadata($className)
+
+    /**
+     * Retrieve ClassMetadata associated to entity class name.
+     *
+     * @param string $className
+     *
+     * @return Doctrine\ORM\Mapping\ClassMetadata
+     */
+    private function getClassMetadata($className)
     {
         if ( ! isset($this->_ce[$className])) {
             $this->_ce[$className] = $this->_em->getClassMetadata($className);
         }
+
         return $this->_ce[$className];
     }
 }

lib/Doctrine/ORM/Internal/Hydration/HydrationException.php

@@ -8,10 +8,19 @@ class HydrationException extends \Doctrine\ORM\ORMException
     {
         return new self("The result returned by the query was not unique.");
     }
-    
+
     public static function parentObjectOfRelationNotFound($alias, $parentAlias)
     {
         return new self("The parent object of entity result with alias '$alias' was not found."
                 . " The parent alias is '$parentAlias'.");
     }
+
+    public static function emptyDiscriminatorValue($dqlAlias)
+    {
+        return new self("The DQL alias '" . $dqlAlias . "' contains an entity ".
+            "of an inheritance hierachy with an empty discriminator value. This means " .
+            "that the database contains inconsistent data with an empty " .
+            "discriminator value in a table row."
+        );
+    }
 }

lib/Doctrine/ORM/Internal/Hydration/ObjectHydrator.php

@@ -29,9 +29,16 @@ use PDO,
 /**
  * The ObjectHydrator constructs an object graph out of an SQL result set.
  *
+ * @since  2.0
  * @author Roman Borschel <roman@code-factory.org>
- * @since 2.0
+ * @author Guilherme Blanco <guilhermeblanoc@hotmail.com>
+ *
  * @internal Highly performance-sensitive code.
+ *
+ * @todo General behavior is "wrong" if you define an alias to selected IdentificationVariable.
+ * Example: SELECT u AS user FROM User u
+ * The result should contains an array where each array index is an array: array('user' => [User object])
+ * Problem must be solved somehow by removing the isMixed in ResultSetMapping
  */
 class ObjectHydrator extends AbstractHydrator
 {
@@ -53,59 +60,63 @@ class ObjectHydrator extends AbstractHydrator
 
 
     /** @override */
-    protected function _prepare()
+    protected function prepare()
     {
         $this->_identifierMap =
         $this->_resultPointers =
         $this->_idTemplate = array();
+
         $this->_resultCounter = 0;
-        if (!isset($this->_hints['deferEagerLoad'])) {
+
+        if ( ! isset($this->_hints['deferEagerLoad'])) {
             $this->_hints['deferEagerLoad'] = true;
         }
-        
+
         foreach ($this->_rsm->aliasMap as $dqlAlias => $className) {
             $this->_identifierMap[$dqlAlias] = array();
-            $this->_idTemplate[$dqlAlias] = '';
-            $class = $this->_em->getClassMetadata($className);
+            $this->_idTemplate[$dqlAlias]    = '';
 
             if ( ! isset($this->_ce[$className])) {
-                $this->_ce[$className] = $class;
+                $this->_ce[$className] = $this->_em->getClassMetadata($className);
             }
 
             // Remember which associations are "fetch joined", so that we know where to inject
             // collection stubs or proxies and where not.
-            if (isset($this->_rsm->relationMap[$dqlAlias])) {
-                if ( ! isset($this->_rsm->aliasMap[$this->_rsm->parentAliasMap[$dqlAlias]])) {
-                    throw HydrationException::parentObjectOfRelationNotFound($dqlAlias, $this->_rsm->parentAliasMap[$dqlAlias]);
+            if ( ! isset($this->_rsm->relationMap[$dqlAlias])) {
+                continue;
+            }
+
+            if ( ! isset($this->_rsm->aliasMap[$this->_rsm->parentAliasMap[$dqlAlias]])) {
+                throw HydrationException::parentObjectOfRelationNotFound($dqlAlias, $this->_rsm->parentAliasMap[$dqlAlias]);
+            }
+
+            $sourceClassName = $this->_rsm->aliasMap[$this->_rsm->parentAliasMap[$dqlAlias]];
+            $sourceClass     = $this->_getClassMetadata($sourceClassName);
+            $assoc           = $sourceClass->associationMappings[$this->_rsm->relationMap[$dqlAlias]];
+
+            $this->_hints['fetched'][$this->_rsm->parentAliasMap[$dqlAlias]][$assoc['fieldName']] = true;
+
+            if ($assoc['type'] === ClassMetadata::MANY_TO_MANY) {
+                continue;
+            }
+
+            // Mark any non-collection opposite sides as fetched, too.
+            if ($assoc['mappedBy']) {
+                $this->_hints['fetched'][$dqlAlias][$assoc['mappedBy']] = true;
+
+                continue;
+            }
+
+            // handle fetch-joined owning side bi-directional one-to-one associations
+            if ($assoc['inversedBy']) {
+                $class        = $this->_ce[$className];
+                $inverseAssoc = $class->associationMappings[$assoc['inversedBy']];
+
+                if ( ! ($inverseAssoc['type'] & ClassMetadata::TO_ONE)) {
+                    continue;
                 }
 
-                $sourceClassName = $this->_rsm->aliasMap[$this->_rsm->parentAliasMap[$dqlAlias]];
-                $sourceClass = $this->_getClassMetadata($sourceClassName);
-                $assoc = $sourceClass->associationMappings[$this->_rsm->relationMap[$dqlAlias]];
-                $this->_hints['fetched'][$sourceClassName][$assoc['fieldName']] = true;
-                if ($sourceClass->subClasses) {
-                    foreach ($sourceClass->subClasses as $sourceSubclassName) {
-                        $this->_hints['fetched'][$sourceSubclassName][$assoc['fieldName']] = true;
-                    }
-                }
-                if ($assoc['type'] != ClassMetadata::MANY_TO_MANY) {
-                    // Mark any non-collection opposite sides as fetched, too.
-                    if ($assoc['mappedBy']) {
-                        $this->_hints['fetched'][$className][$assoc['mappedBy']] = true;
-                    } else {
-                        if ($assoc['inversedBy']) {
-                            $inverseAssoc = $class->associationMappings[$assoc['inversedBy']];
-                            if ($inverseAssoc['type'] & ClassMetadata::TO_ONE) {
-                                $this->_hints['fetched'][$className][$inverseAssoc['fieldName']] = true;
-                                if ($class->subClasses) {
-                                    foreach ($class->subClasses as $targetSubclassName) {
-                                        $this->_hints['fetched'][$targetSubclassName][$inverseAssoc['fieldName']] = true;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+                $this->_hints['fetched'][$dqlAlias][$inverseAssoc['fieldName']] = true;
             }
         }
     }
@@ -113,16 +124,17 @@ class ObjectHydrator extends AbstractHydrator
     /**
      * {@inheritdoc}
      */
-    protected function _cleanup()
+    protected function cleanup()
     {
         $eagerLoad = (isset($this->_hints['deferEagerLoad'])) && $this->_hints['deferEagerLoad'] == true;
-        
-        parent::_cleanup();
+
+        parent::cleanup();
+
         $this->_identifierMap =
         $this->_initializedCollections =
         $this->_existingCollections =
         $this->_resultPointers = array();
-        
+
         if ($eagerLoad) {
             $this->_em->getUnitOfWork()->triggerEagerLoads();
         }
@@ -131,13 +143,13 @@ class ObjectHydrator extends AbstractHydrator
     /**
      * {@inheritdoc}
      */
-    protected function _hydrateAll()
+    protected function hydrateAllData()
     {
         $result = array();
-        $cache = array();
+        $cache  = array();
 
         while ($row = $this->_stmt->fetch(PDO::FETCH_ASSOC)) {
-            $this->_hydrateRow($row, $cache, $result);
+            $this->hydrateRowData($row, $cache, $result);
         }
 
         // Take snapshots from all newly initialized collections
@@ -152,35 +164,40 @@ class ObjectHydrator extends AbstractHydrator
      * Initializes a related collection.
      *
      * @param object $entity The entity to which the collection belongs.
+     * @param ClassMetadata $class
      * @param string $name The name of the field on the entity that holds the collection.
+     * @param string $parentDqlAlias Alias of the parent fetch joining this collection.
      */
-    private function _initRelatedCollection($entity, $class, $fieldName)
+    private function _initRelatedCollection($entity, $class, $fieldName, $parentDqlAlias)
     {
-        $oid = spl_object_hash($entity);
+        $oid      = spl_object_hash($entity);
         $relation = $class->associationMappings[$fieldName];
+        $value    = $class->reflFields[$fieldName]->getValue($entity);
 
-        $value = $class->reflFields[$fieldName]->getValue($entity);
         if ($value === null) {
             $value = new ArrayCollection;
         }
 
         if ( ! $value instanceof PersistentCollection) {
             $value = new PersistentCollection(
-                $this->_em,
-                $this->_ce[$relation['targetEntity']],
-                $value
+                $this->_em, $this->_ce[$relation['targetEntity']], $value
             );
             $value->setOwner($entity, $relation);
+
             $class->reflFields[$fieldName]->setValue($entity, $value);
             $this->_uow->setOriginalEntityProperty($oid, $fieldName, $value);
+
             $this->_initializedCollections[$oid . $fieldName] = $value;
-        } else if (isset($this->_hints[Query::HINT_REFRESH]) ||
-                isset($this->_hints['fetched'][$class->name][$fieldName]) &&
-                ! $value->isInitialized()) {
+        } else if (
+            isset($this->_hints[Query::HINT_REFRESH]) ||
+            isset($this->_hints['fetched'][$parentDqlAlias][$fieldName]) &&
+             ! $value->isInitialized()
+        ) {
             // Is already PersistentCollection, but either REFRESH or FETCH-JOIN and UNINITIALIZED!
             $value->setDirty(false);
             $value->setInitialized(true);
             $value->unwrap()->clear();
+
             $this->_initializedCollections[$oid . $fieldName] = $value;
         } else {
             // Is already PersistentCollection, and DON'T REFRESH or FETCH-JOIN!
@@ -192,7 +209,7 @@ class ObjectHydrator extends AbstractHydrator
 
     /**
      * Gets an entity instance.
-     * 
+     *
      * @param $data The instance data.
      * @param $dqlAlias The DQL alias of the entity's class.
      * @return object The entity.
@@ -200,17 +217,24 @@ class ObjectHydrator extends AbstractHydrator
     private function _getEntity(array $data, $dqlAlias)
     {
         $className = $this->_rsm->aliasMap[$dqlAlias];
+
         if (isset($this->_rsm->discriminatorColumns[$dqlAlias])) {
             $discrColumn = $this->_rsm->metaMappings[$this->_rsm->discriminatorColumns[$dqlAlias]];
+
+            if ($data[$discrColumn] === "") {
+                throw HydrationException::emptyDiscriminatorValue($dqlAlias);
+            }
+
             $className = $this->_ce[$className]->discriminatorMap[$data[$discrColumn]];
+
             unset($data[$discrColumn]);
         }
-        
+
         if (isset($this->_hints[Query::HINT_REFRESH_ENTITY]) && isset($this->_rootAliases[$dqlAlias])) {
-            $class = $this->_ce[$className];
-            $this->registerManaged($class, $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
+            $this->registerManaged($this->_ce[$className], $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
         }
-        
+
+        $this->_hints['fetchAlias'] = $dqlAlias;
         return $this->_uow->createEntity($className, $data, $this->_hints);
     }
 
@@ -218,6 +242,7 @@ class ObjectHydrator extends AbstractHydrator
     {
         // TODO: Abstract this code and UnitOfWork::createEntity() equivalent?
         $class = $this->_ce[$className];
+
         /* @var $class ClassMetadata */
         if ($class->isIdentifierComposite) {
             $idHash = '';
@@ -240,7 +265,7 @@ class ObjectHydrator extends AbstractHydrator
      * Gets a ClassMetadata instance from the local cache.
      * If the instance is not yet in the local cache, it is loaded into the
      * local cache.
-     * 
+     *
      * @param string $className The name of the class.
      * @return ClassMetadata
      */
@@ -249,42 +274,45 @@ class ObjectHydrator extends AbstractHydrator
         if ( ! isset($this->_ce[$className])) {
             $this->_ce[$className] = $this->_em->getClassMetadata($className);
         }
+
         return $this->_ce[$className];
     }
 
     /**
      * Hydrates a single row in an SQL result set.
-     * 
+     *
      * @internal
      * First, the data of the row is split into chunks where each chunk contains data
      * that belongs to a particular component/class. Afterwards, all these chunks
      * are processed, one after the other. For each chunk of class data only one of the
      * following code paths is executed:
-     * 
+     *
      * Path A: The data chunk belongs to a joined/associated object and the association
      *         is collection-valued.
      * Path B: The data chunk belongs to a joined/associated object and the association
      *         is single-valued.
      * Path C: The data chunk belongs to a root result element/object that appears in the topmost
      *         level of the hydrated result. A typical example are the objects of the type
-     *         specified by the FROM clause in a DQL query. 
-     * 
+     *         specified by the FROM clause in a DQL query.
+     *
      * @param array $data The data of the row to process.
      * @param array $cache The cache to use.
      * @param array $result The result array to fill.
      */
-    protected function _hydrateRow(array $data, array &$cache, array &$result)
+    protected function hydrateRowData(array $row, array &$cache, array &$result)
     {
         // Initialize
         $id = $this->_idTemplate; // initialize the id-memory
         $nonemptyComponents = array();
         // Split the row data into chunks of class data.
-        $rowData = $this->_gatherRowData($data, $cache, $id, $nonemptyComponents);
+        $rowData = $this->gatherRowData($row, $cache, $id, $nonemptyComponents);
 
         // Extract scalar values. They're appended at the end.
         if (isset($rowData['scalars'])) {
             $scalars = $rowData['scalars'];
+
             unset($rowData['scalars']);
+
             if (empty($rowData)) {
                 ++$this->_resultCounter;
             }
@@ -311,7 +339,7 @@ class ObjectHydrator extends AbstractHydrator
                 // Get a reference to the parent object to which the joined element belongs.
                 if ($this->_rsm->isMixed && isset($this->_rootAliases[$parentAlias])) {
                     $first = reset($this->_resultPointers);
-                    $parentObject = $this->_resultPointers[$parentAlias][key($first)];
+                    $parentObject = $first[key($first)];
                 } else if (isset($this->_resultPointers[$parentAlias])) {
                     $parentObject = $this->_resultPointers[$parentAlias];
                 } else {
@@ -333,7 +361,7 @@ class ObjectHydrator extends AbstractHydrator
                         if (isset($this->_initializedCollections[$collKey])) {
                             $reflFieldValue = $this->_initializedCollections[$collKey];
                         } else if ( ! isset($this->_existingCollections[$collKey])) {
-                            $reflFieldValue = $this->_initRelatedCollection($parentObject, $parentClass, $relationField);
+                            $reflFieldValue = $this->_initRelatedCollection($parentObject, $parentClass, $relationField, $parentAlias);
                         }
 
                         $indexExists = isset($this->_identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]]);
@@ -352,8 +380,7 @@ class ObjectHydrator extends AbstractHydrator
                                 $element = $this->_getEntity($data, $dqlAlias);
 
                                 if (isset($this->_rsm->indexByMap[$dqlAlias])) {
-                                    $field = $this->_rsm->indexByMap[$dqlAlias];
-                                    $indexValue = $this->_ce[$entityName]->reflFields[$field]->getValue($element);
+                                    $indexValue = $row[$this->_rsm->indexByMap[$dqlAlias]];
                                     $reflFieldValue->hydrateSet($indexValue, $element);
                                     $this->_identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $indexValue;
                                 } else {
@@ -369,10 +396,7 @@ class ObjectHydrator extends AbstractHydrator
                             $this->_resultPointers[$dqlAlias] = $reflFieldValue[$index];
                         }
                     } else if ( ! $reflField->getValue($parentObject)) {
-                        $coll = new PersistentCollection($this->_em, $this->_ce[$entityName], new ArrayCollection);
-                        $coll->setOwner($parentObject, $relation);
-                        $reflField->setValue($parentObject, $coll);
-                        $this->_uow->setOriginalEntityProperty($oid, $relationField, $coll);
+                        $reflFieldValue = $this->_initRelatedCollection($parentObject, $parentClass, $relationField, $parentAlias);
                     }
                 } else {
                     // PATH B: Single-valued association
@@ -383,6 +407,7 @@ class ObjectHydrator extends AbstractHydrator
                             $reflField->setValue($parentObject, $element);
                             $this->_uow->setOriginalEntityProperty($oid, $relationField, $element);
                             $targetClass = $this->_ce[$relation['targetEntity']];
+
                             if ($relation['isOwningSide']) {
                                 //TODO: Just check hints['fetched'] here?
                                 // If there is an inverse mapping on the target class its bidirectional
@@ -413,14 +438,16 @@ class ObjectHydrator extends AbstractHydrator
             } else {
                 // PATH C: Its a root result element
                 $this->_rootAliases[$dqlAlias] = true; // Mark as root alias
+                $entityKey = $this->_rsm->entityMappings[$dqlAlias] ?: 0;
 
                 // if this row has a NULL value for the root result id then make it a null result.
                 if ( ! isset($nonemptyComponents[$dqlAlias]) ) {
                     if ($this->_rsm->isMixed) {
-                        $result[] = array(0 => null);
+                        $result[] = array($entityKey => null);
                     } else {
                         $result[] = null;
                     }
+                    $resultKey = $this->_resultCounter;
                     ++$this->_resultCounter;
                     continue;
                 }
@@ -428,35 +455,31 @@ class ObjectHydrator extends AbstractHydrator
                 // check for existing result from the iterations before
                 if ( ! isset($this->_identifierMap[$dqlAlias][$id[$dqlAlias]])) {
                     $element = $this->_getEntity($rowData[$dqlAlias], $dqlAlias);
+                    if ($this->_rsm->isMixed) {
+                        $element = array($entityKey => $element);
+                    }
+
                     if (isset($this->_rsm->indexByMap[$dqlAlias])) {
-                        $field = $this->_rsm->indexByMap[$dqlAlias];
-                        $key = $this->_ce[$entityName]->reflFields[$field]->getValue($element);
-                        if ($this->_rsm->isMixed) {
-                            $element = array($key => $element);
-                            $result[] = $element;
-                            $this->_identifierMap[$dqlAlias][$id[$dqlAlias]] = $this->_resultCounter;
-                            ++$this->_resultCounter;
-                        } else {
-                            $result[$key] = $element;
-                            $this->_identifierMap[$dqlAlias][$id[$dqlAlias]] = $key;
-                        }
+                        $resultKey = $row[$this->_rsm->indexByMap[$dqlAlias]];
 
                         if (isset($this->_hints['collection'])) {
-                            $this->_hints['collection']->hydrateSet($key, $element);
+                            $this->_hints['collection']->hydrateSet($resultKey, $element);
                         }
+
+                        $result[$resultKey] = $element;
                     } else {
-                        if ($this->_rsm->isMixed) {
-                            $element = array(0 => $element);
-                        }
-                        $result[] = $element;
-                        $this->_identifierMap[$dqlAlias][$id[$dqlAlias]] = $this->_resultCounter;
+                        $resultKey = $this->_resultCounter;
                         ++$this->_resultCounter;
 
                         if (isset($this->_hints['collection'])) {
                             $this->_hints['collection']->hydrateAdd($element);
                         }
+
+                        $result[] = $element;
                     }
 
+                    $this->_identifierMap[$dqlAlias][$id[$dqlAlias]] = $resultKey;
+
                     // Update result pointer
                     $this->_resultPointers[$dqlAlias] = $element;
 
@@ -464,6 +487,7 @@ class ObjectHydrator extends AbstractHydrator
                     // Update result pointer
                     $index = $this->_identifierMap[$dqlAlias][$id[$dqlAlias]];
                     $this->_resultPointers[$dqlAlias] = $result[$index];
+                    $resultKey = $index;
                     /*if ($this->_rsm->isMixed) {
                         $result[] = $result[$index];
                         ++$this->_resultCounter;
@@ -474,8 +498,16 @@ class ObjectHydrator extends AbstractHydrator
 
         // Append scalar values to mixed result sets
         if (isset($scalars)) {
+            if ( ! isset($resultKey) ) {
+                if (isset($this->_rsm->indexByMap['scalars'])) {
+                    $resultKey = $row[$this->_rsm->indexByMap['scalars']];
+                } else {
+                    $resultKey = $this->_resultCounter - 1;
+                }
+            }
+
             foreach ($scalars as $name => $value) {
-                $result[$this->_resultCounter - 1][$name] = $value;
+                $result[$resultKey][$name] = $value;
             }
         }
     }

lib/Doctrine/ORM/Internal/Hydration/ScalarHydrator.php

@@ -26,25 +26,32 @@ use Doctrine\DBAL\Connection;
  * The created result is almost the same as a regular SQL result set, except
  * that column names are mapped to field names and data type conversions take place.
  *
+ * @since  2.0
  * @author Roman Borschel <roman@code-factory.org>
- * @since 2.0
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
  */
 class ScalarHydrator extends AbstractHydrator
 {
-    /** @override */
-    protected function _hydrateAll()
+    /** 
+     * {@inheritdoc}
+     */
+    protected function hydrateAllData()
     {
         $result = array();
-        $cache = array();
+        $cache  = array();
+        
         while ($data = $this->_stmt->fetch(\PDO::FETCH_ASSOC)) {
-            $result[] = $this->_gatherScalarRowData($data, $cache);
+            $this->hydrateRowData($data, $cache, $result);
         }
+        
         return $result;
     }
 
-    /** @override */
-    protected function _hydrateRow(array $data, array &$cache, array &$result)
+    /** 
+     * {@inheritdoc}
+     */
+    protected function hydrateRowData(array $data, array &$cache, array &$result)
     {
-        $result[] = $this->_gatherScalarRowData($data, $cache);
+        $result[] = $this->gatherScalarRowData($data, $cache);
     }
 }

lib/Doctrine/ORM/Internal/Hydration/SimpleObjectHydrator.php

@@ -17,7 +17,6 @@
  * <http://www.doctrine-project.org>.
  */
 
-
 namespace Doctrine\ORM\Internal\Hydration;
 
 use \PDO;
@@ -32,15 +31,21 @@ class SimpleObjectHydrator extends AbstractHydrator
      */
     private $class;
 
+    /**
+     * @var array
+     */
     private $declaringClasses = array();
 
-    protected function _hydrateAll()
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateAllData()
     {
         $result = array();
         $cache = array();
 
         while ($row = $this->_stmt->fetch(PDO::FETCH_ASSOC)) {
-            $this->_hydrateRow($row, $cache, $result);
+            $this->hydrateRowData($row, $cache, $result);
         }
 
         $this->_em->getUnitOfWork()->triggerEagerLoads();
@@ -48,77 +53,71 @@ class SimpleObjectHydrator extends AbstractHydrator
         return $result;
     }
 
-    protected function _prepare()
+    /**
+     * {@inheritdoc}
+     */
+    protected function prepare()
     {
-        if (count($this->_rsm->aliasMap) == 1) {
-            $this->class = $this->_em->getClassMetadata(reset($this->_rsm->aliasMap));
-            if ($this->class->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
-                foreach ($this->_rsm->declaringClasses AS $column => $class) {
-                    $this->declaringClasses[$column] = $this->_em->getClassMetadata($class);
-                }
-            }
-        } else {
-            throw new \RuntimeException("Cannot use SimpleObjectHydrator with a ResultSetMapping not containing exactly one object result.");
+        if (count($this->_rsm->aliasMap) !== 1) {
+            throw new \RuntimeException("Cannot use SimpleObjectHydrator with a ResultSetMapping that contains more than one object result.");
         }
+        
         if ($this->_rsm->scalarMappings) {
             throw new \RuntimeException("Cannot use SimpleObjectHydrator with a ResultSetMapping that contains scalar mappings.");
         }
+        
+        $this->class = $this->_em->getClassMetadata(reset($this->_rsm->aliasMap));
+        
+        // We only need to add declaring classes if we have inheritance.
+        if ($this->class->inheritanceType === ClassMetadata::INHERITANCE_TYPE_NONE) {
+            return;
+        }
+        
+        foreach ($this->_rsm->declaringClasses AS $column => $class) {
+            $this->declaringClasses[$column] = $this->_em->getClassMetadata($class);
+        }
     }
 
-    protected function _hydrateRow(array $sqlResult, array &$cache, array &$result)
+    /**
+     * {@inheritdoc}
+     */
+    protected function hydrateRowData(array $sqlResult, array &$cache, array &$result)
     {
-        $data = array();
-        if ($this->class->inheritanceType == ClassMetadata::INHERITANCE_TYPE_NONE) {
-            foreach ($sqlResult as $column => $value) {
-
-                if (!isset($cache[$column])) {
-                    if (isset($this->_rsm->fieldMappings[$column])) {
-                        $cache[$column]['name'] = $this->_rsm->fieldMappings[$column];
-                        $cache[$column]['field'] = true;
-                    } else {
-                        $cache[$column]['name'] = $this->_rsm->metaMappings[$column];
-                    }
-                }
-
-                if (isset($cache[$column]['field'])) {
-                    $value = Type::getType($this->class->fieldMappings[$cache[$column]['name']]['type'])
-                                    ->convertToPHPValue($value, $this->_platform);
-                }
-                $data[$cache[$column]['name']] = $value;
-            }
-            $entityName = $this->class->name;
-        } else {
+        $entityName = $this->class->name;
+        $data       = array();
+        
+        // We need to find the correct entity class name if we have inheritance in resultset
+        if ($this->class->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
             $discrColumnName = $this->_platform->getSQLResultCasing($this->class->discriminatorColumn['name']);
+            
+            if ($sqlResult[$discrColumnName] === '') {
+                throw HydrationException::emptyDiscriminatorValue(key($this->_rsm->aliasMap));
+            }
+
             $entityName = $this->class->discriminatorMap[$sqlResult[$discrColumnName]];
+            
             unset($sqlResult[$discrColumnName]);
-            foreach ($sqlResult as $column => $value) {
-                if (!isset($cache[$column])) {
-                    if (isset($this->_rsm->fieldMappings[$column])) {
-                        $field = $this->_rsm->fieldMappings[$column];
-                        $class = $this->declaringClasses[$column];
-                        if ($class->name == $entityName || is_subclass_of($entityName, $class->name)) {
-                            $cache[$column]['name'] = $field;
-                            $cache[$column]['class'] = $class;
-                        }
-                    } else if (isset($this->_rsm->relationMap[$column])) {
-                        if ($this->_rsm->relationMap[$column] == $entityName || is_subclass_of($entityName, $this->_rsm->relationMap[$column])) {
-                            $cache[$column]['name'] = $field;
-                        }
-                    } else {
-                        $cache[$column]['name'] = $this->_rsm->metaMappings[$column];
-                    }
+        }
+        
+        foreach ($sqlResult as $column => $value) {
+            // Hydrate column information if not yet present
+            if ( ! isset($cache[$column])) {
+                if (($info = $this->hydrateColumnInfo($entityName, $column)) === null) {
+                    continue;
                 }
+                
+                $cache[$column] = $info;
+            }
 
-                if (isset($cache[$column]['class'])) {
-                    $value = Type::getType($cache[$column]['class']->fieldMappings[$cache[$column]['name']]['type'])
-                                    ->convertToPHPValue($value, $this->_platform);
-                }
-
-                // the second and part is to prevent overwrites in case of multiple
-                // inheritance classes using the same property name (See AbstractHydrator)
-                if (isset($cache[$column]) && (!isset($data[$cache[$column]['name']]) || $value !== null)) {
-                    $data[$cache[$column]['name']] = $value;
-                }
+            // Convert field to a valid PHP value
+            if (isset($cache[$column]['field'])) {
+                $type  = Type::getType($cache[$column]['class']->fieldMappings[$cache[$column]['name']]['type']);
+                $value = $type->convertToPHPValue($value, $this->_platform);
+            }
+            
+            // Prevent overwrite in case of inherit classes using same property name (See AbstractHydrator)
+            if (isset($cache[$column]) && ( ! isset($data[$cache[$column]['name']]) || $value !== null)) {
+                $data[$cache[$column]['name']] = $value;
             }
         }
 
@@ -128,4 +127,52 @@ class SimpleObjectHydrator extends AbstractHydrator
 
         $result[] = $this->_em->getUnitOfWork()->createEntity($entityName, $data, $this->_hints);
     }
+    
+    /**
+     * Retrieve column information form ResultSetMapping.
+     * 
+     * @param string $entityName
+     * @param string $column
+     * 
+     * @return array 
+     */
+    protected function hydrateColumnInfo($entityName, $column)
+    {
+        switch (true) {
+            case (isset($this->_rsm->fieldMappings[$column])):
+                $class = isset($this->declaringClasses[$column]) 
+                    ? $this->declaringClasses[$column] 
+                    : $this->class;
+
+                // If class is not part of the inheritance, ignore
+                if ( ! ($class->name === $entityName || is_subclass_of($entityName, $class->name))) {
+                    return null;
+                }
+
+                return array(
+                    'class' => $class,
+                    'name'  => $this->_rsm->fieldMappings[$column],
+                    'field' => true,
+                );
+
+            case (isset($this->_rsm->relationMap[$column])):
+                $class = isset($this->_rsm->relationMap[$column]) 
+                    ? $this->_rsm->relationMap[$column] 
+                    : $this->class;
+
+                // If class is not self referencing, ignore
+                if ( ! ($class === $entityName || is_subclass_of($entityName, $class))) {
+                    return null;
+                }
+
+                // TODO: Decide what to do with associations. It seems original code is incomplete. 
+                // One solution is to load the association, but it might require extra efforts.
+                return array('name' => $column);
+
+            default:
+                return array(
+                    'name' => $this->_rsm->metaMappings[$column]
+                );
+        }
+    }
 }

lib/Doctrine/ORM/Internal/Hydration/SingleScalarHydrator.php

@@ -19,30 +19,37 @@
 
 namespace Doctrine\ORM\Internal\Hydration;
 
-use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Connection,
+    Doctrine\ORM\NoResultException,
+    Doctrine\ORM\NonUniqueResultException;
 
 /**
  * Hydrator that hydrates a single scalar value from the result set.
  *
+ * @since  2.0
  * @author Roman Borschel <roman@code-factory.org>
- * @since 2.0
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
  */
 class SingleScalarHydrator extends AbstractHydrator
 {
-    /** @override */
-    protected function _hydrateAll()
+    /**
+     * {@inheritdoc} 
+     */
+    protected function hydrateAllData()
     {
-        $cache = array();
-        $result = $this->_stmt->fetchAll(\PDO::FETCH_ASSOC);
-        $num = count($result);
-
-        if ($num == 0) {
-            throw new \Doctrine\ORM\NoResultException;
-        } else if ($num > 1 || count($result[key($result)]) > 1) {
-            throw new \Doctrine\ORM\NonUniqueResultException;
+        $data    = $this->_stmt->fetchAll(\PDO::FETCH_ASSOC);
+        $numRows = count($data);
+        
+        if ($numRows === 0) {
+            throw new NoResultException();
         }
         
-        $result = $this->_gatherScalarRowData($result[key($result)], $cache);
+        if ($numRows > 1 || count($data[key($data)]) > 1) {
+            throw new NonUniqueResultException();
+        }
+        
+        $cache  = array();
+        $result = $this->gatherScalarRowData($data[key($data)], $cache);
         
         return array_shift($result);
     }

lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php

@@ -312,6 +312,10 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
             if ($parent && $parent->containsForeignIdentifier) {
                 $class->containsForeignIdentifier = true;
             }
+            
+            if ($parent && !empty ($parent->namedQueries)) {
+                $this->addInheritedNamedQueries($class, $parent);
+            }
 
             $class->setParentClasses($visited);
 
@@ -428,6 +432,25 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
             $subClass->addInheritedAssociationMapping($mapping);
         }
     }
+    
+    /**
+     * Adds inherited named queries to the subclass mapping.
+     * 
+     * @since 2.2
+     * @param Doctrine\ORM\Mapping\ClassMetadata $subClass
+     * @param Doctrine\ORM\Mapping\ClassMetadata $parentClass
+     */
+    private function addInheritedNamedQueries(ClassMetadata $subClass, ClassMetadata $parentClass)
+    {
+        foreach ($parentClass->namedQueries as $name => $query) {
+            if (!isset ($subClass->namedQueries[$name])) {
+                $subClass->addNamedQuery(array(
+                    'name'  => $query['name'],
+                    'query' => $query['query']
+                ));
+            }
+        }
+    }
 
     /**
      * Completes the ID generator mapping. If "auto" is specified we choose the generator

lib/Doctrine/ORM/Mapping/ClassMetadataInfo.php

@@ -20,6 +20,7 @@
 namespace Doctrine\ORM\Mapping;
 
 use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+use Doctrine\DBAL\Types\Type;
 use ReflectionClass;
 
 /**
@@ -119,7 +120,7 @@ class ClassMetadataInfo implements ClassMetadata
     const FETCH_LAZY = 2;
     /**
      * Specifies that an association is to be fetched when the owner of the
-     * association is fetched. 
+     * association is fetched.
      */
     const FETCH_EAGER = 3;
     /**
@@ -136,10 +137,6 @@ class ClassMetadataInfo implements ClassMetadata
      * Identifies a many-to-one association.
      */
     const MANY_TO_ONE = 2;
-    /**
-     * Combined bitmask for to-one (single-valued) associations.
-     */
-    const TO_ONE = 3;
     /**
      * Identifies a one-to-many association.
      */
@@ -148,6 +145,10 @@ class ClassMetadataInfo implements ClassMetadata
      * Identifies a many-to-many association.
      */
     const MANY_TO_MANY = 8;
+    /**
+     * Combined bitmask for to-one (single-valued) associations.
+     */
+    const TO_ONE = 3;
     /**
      * Combined bitmask for to-many (collection-valued) associations.
      */
@@ -206,7 +207,7 @@ class ClassMetadataInfo implements ClassMetadata
 
     /**
      * READ-ONLY: The named queries allowed to be called directly from Repository.
-     * 
+     *
      * @var array
      */
     public $namedQueries = array();
@@ -318,7 +319,7 @@ class ClassMetadataInfo implements ClassMetadata
     public $discriminatorMap = array();
 
     /**
-     * READ-ONLY: The definition of the descriminator column used in JOINED and SINGLE_TABLE
+     * READ-ONLY: The definition of the discriminator column used in JOINED and SINGLE_TABLE
      * inheritance mappings.
      *
      * @var array
@@ -361,7 +362,7 @@ class ClassMetadataInfo implements ClassMetadata
      * - <b>mappedBy</b> (string, required for bidirectional associations)
      * The name of the field that completes the bidirectional association on the owning side.
      * This key must be specified on the inverse side of a bidirectional association.
-     * 
+     *
      * - <b>inversedBy</b> (string, required for bidirectional associations)
      * The name of the field that completes the bidirectional association on the inverse side.
      * This key must be specified on the owning side of a bidirectional association.
@@ -388,7 +389,7 @@ class ClassMetadataInfo implements ClassMetadata
      * Specification of a field on target-entity that is used to index the collection by.
      * This field HAS to be either the primary key or a unique column. Otherwise the collection
      * does not contain all the entities that are actually related.
-     * 
+     *
      * A join table definition has the following structure:
      * <pre>
      * array(
@@ -430,7 +431,7 @@ class ClassMetadataInfo implements ClassMetadata
     /**
      * READ-ONLY: The definition of the sequence generator of this class. Only used for the
      * SEQUENCE generation strategy.
-     * 
+     *
      * The definition has the following structure:
      * <code>
      * array(
@@ -685,7 +686,7 @@ class ClassMetadataInfo implements ClassMetadata
         if ( ! isset($this->namedQueries[$queryName])) {
             throw MappingException::queryNotFound($this->name, $queryName);
         }
-        return $this->namedQueries[$queryName];
+        return $this->namedQueries[$queryName]['dql'];
     }
 
     /**
@@ -746,6 +747,14 @@ class ClassMetadataInfo implements ClassMetadata
                 $this->isIdentifierComposite = true;
             }
         }
+
+        if (Type::hasType($mapping['type']) && Type::getType($mapping['type'])->canRequireSQLConversion()) {
+            if (isset($mapping['id']) && $mapping['id'] === true) {
+                 throw MappingException::sqlConversionNotAllowedForIdentifiers($this->name, $mapping['fieldName'], $mapping['type']);
+            }
+
+            $mapping['requireSQLConversion'] = true;
+        }
     }
 
     /**
@@ -774,15 +783,22 @@ class ClassMetadataInfo implements ClassMetadata
         // If targetEntity is unqualified, assume it is in the same namespace as
         // the sourceEntity.
         $mapping['sourceEntity'] = $this->name;
-        
+
         if (isset($mapping['targetEntity'])) {
             if (strlen($this->namespace) > 0 && strpos($mapping['targetEntity'], '\\') === false) {
                 $mapping['targetEntity'] = $this->namespace . '\\' . $mapping['targetEntity'];
             }
-            
+
             $mapping['targetEntity'] = ltrim($mapping['targetEntity'], '\\');
         }
 
+        if ( ($mapping['type'] & (self::MANY_TO_ONE|self::MANY_TO_MANY)) > 0 &&
+                isset($mapping['orphanRemoval']) &&
+                $mapping['orphanRemoval'] == true) {
+
+            throw MappingException::illegalOrphanRemoval($this->name, $mapping['fieldName']);
+        }
+
         // Complete id mapping
         if (isset($mapping['id']) && $mapping['id'] === true) {
             if (isset($mapping['orphanRemoval']) && $mapping['orphanRemoval'] == true) {
@@ -813,7 +829,7 @@ class ClassMetadataInfo implements ClassMetadata
         if ( ! isset($mapping['targetEntity'])) {
             throw MappingException::missingTargetEntity($mapping['fieldName']);
         }
-        
+
         // Mandatory and optional attributes for either side
         if ( ! $mapping['mappedBy']) {
             if (isset($mapping['joinTable']) && $mapping['joinTable']) {
@@ -829,7 +845,7 @@ class ClassMetadataInfo implements ClassMetadata
         if (isset($mapping['id']) && $mapping['id'] === true && $mapping['type'] & self::TO_MANY) {
             throw MappingException::illegalToManyIdentifierAssoaction($this->name, $mapping['fieldName']);
         }
-        
+
         // Fetch mode. Default fetch mode to LAZY, if not set.
         if ( ! isset($mapping['fetch'])) {
             $mapping['fetch'] = self::FETCH_LAZY;
@@ -837,18 +853,18 @@ class ClassMetadataInfo implements ClassMetadata
 
         // Cascades
         $cascades = isset($mapping['cascade']) ? array_map('strtolower', $mapping['cascade']) : array();
-        
+
         if (in_array('all', $cascades)) {
             $cascades = array('remove', 'persist', 'refresh', 'merge', 'detach');
         }
-        
+
         $mapping['cascade'] = $cascades;
         $mapping['isCascadeRemove'] = in_array('remove',  $cascades);
         $mapping['isCascadePersist'] = in_array('persist',  $cascades);
         $mapping['isCascadeRefresh'] = in_array('refresh',  $cascades);
         $mapping['isCascadeMerge'] = in_array('merge',  $cascades);
         $mapping['isCascadeDetach'] = in_array('detach',  $cascades);
-        
+
         return $mapping;
     }
 
@@ -862,11 +878,11 @@ class ClassMetadataInfo implements ClassMetadata
     protected function _validateAndCompleteOneToOneMapping(array $mapping)
     {
         $mapping = $this->_validateAndCompleteAssociationMapping($mapping);
-        
+
         if (isset($mapping['joinColumns']) && $mapping['joinColumns']) {
             $mapping['isOwningSide'] = true;
         }
-        
+
         if ($mapping['isOwningSide']) {
             if ( ! isset($mapping['joinColumns']) || ! $mapping['joinColumns']) {
                 // Apply default join column
@@ -933,7 +949,7 @@ class ClassMetadataInfo implements ClassMetadata
         if ( ! isset($mapping['mappedBy'])) {
             throw MappingException::oneToManyRequiresMappedBy($mapping['fieldName']);
         }
-        
+
         $mapping['orphanRemoval']   = isset($mapping['orphanRemoval']) ? (bool) $mapping['orphanRemoval'] : false;
         $mapping['isCascadeRemove'] = $mapping['orphanRemoval'] ? true : $mapping['isCascadeRemove'];
 
@@ -942,7 +958,7 @@ class ClassMetadataInfo implements ClassMetadata
                 throw new \InvalidArgumentException("'orderBy' is expected to be an array, not ".gettype($mapping['orderBy']));
             }
         }
-        
+
         return $mapping;
     }
 
@@ -960,7 +976,7 @@ class ClassMetadataInfo implements ClassMetadata
             } else {
                 $targetShortName = strtolower($mapping['targetEntity']);
             }
-            
+
             // owning side MUST have a join table
             if ( ! isset($mapping['joinTable']['name'])) {
                 $mapping['joinTable']['name'] = $sourceShortName .'_' . $targetShortName;
@@ -1111,23 +1127,23 @@ class ClassMetadataInfo implements ClassMetadata
      */
     public function getIdentifierColumnNames()
     {
-        if ($this->isIdentifierComposite) {
-            $columnNames = array();
-            foreach ($this->identifier as $idField) {
-                if (isset($this->associationMappings[$idField])) {
-                    // no composite pk as fk entity assumption:
-                    $columnNames[] = $this->associationMappings[$idField]['joinColumns'][0]['name'];
-                } else {
-                    $columnNames[] = $this->fieldMappings[$idField]['columnName'];
-                }
+        $columnNames = array();
+
+        foreach ($this->identifier as $idProperty) {
+            if (isset($this->fieldMappings[$idProperty])) {
+                $columnNames[] = $this->fieldMappings[$idProperty]['columnName'];
+
+                continue;
             }
-            return $columnNames;
-        } else if(isset($this->fieldMappings[$this->identifier[0]])) {
-            return array($this->fieldMappings[$this->identifier[0]]['columnName']);
-        } else {
-            // no composite pk as fk entity assumption:
-            return array($this->associationMappings[$this->identifier[0]]['joinColumns'][0]['name']);
+
+            // Association defined as Id field
+            $joinColumns      = $this->associationMappings[$idProperty]['joinColumns'];
+            $assocColumnNames = array_map(function ($joinColumn) { return $joinColumn['name']; }, $joinColumns);
+
+            $columnNames = array_merge($columnNames, $assocColumnNames);
         }
+
+        return $columnNames;
     }
 
     /**
@@ -1369,11 +1385,11 @@ class ClassMetadataInfo implements ClassMetadata
                 $this->table['name'] = $table['name'];
             }
         }
-        
+
         if (isset($table['indexes'])) {
             $this->table['indexes'] = $table['indexes'];
         }
-        
+
         if (isset($table['uniqueConstraints'])) {
             $this->table['uniqueConstraints'] = $table['uniqueConstraints'];
         }
@@ -1448,8 +1464,15 @@ class ClassMetadataInfo implements ClassMetadata
         if (isset($this->namedQueries[$queryMapping['name']])) {
             throw MappingException::duplicateQueryMapping($this->name, $queryMapping['name']);
         }
-        $query = str_replace('__CLASS__', $this->name, $queryMapping['query']);
-        $this->namedQueries[$queryMapping['name']] = $query;
+
+        $name   = $queryMapping['name'];
+        $query  = $queryMapping['query'];
+        $dql    = str_replace('__CLASS__', $this->name, $query);
+        $this->namedQueries[$name] = array(
+            'name'  => $name,
+            'query' => $query,
+            'dql'   => $dql
+        );
     }
 
     /**
@@ -1504,14 +1527,16 @@ class ClassMetadataInfo implements ClassMetadata
     /**
      * Stores the association mapping.
      *
-     * @param AssociationMapping $assocMapping
+     * @param array $assocMapping
      */
     protected function _storeAssociationMapping(array $assocMapping)
     {
         $sourceFieldName = $assocMapping['fieldName'];
+
         if (isset($this->fieldMappings[$sourceFieldName]) || isset($this->associationMappings[$sourceFieldName])) {
             throw MappingException::duplicateFieldMapping($this->name, $sourceFieldName);
         }
+
         $this->associationMappings[$sourceFieldName] = $assocMapping;
     }
 
@@ -1522,7 +1547,7 @@ class ClassMetadataInfo implements ClassMetadata
      */
     public function setCustomRepositoryClass($repositoryClassName)
     {
-        if ($repositoryClassName !== null && strpos($repositoryClassName, '\\') === false 
+        if ($repositoryClassName !== null && strpos($repositoryClassName, '\\') === false
                 && strlen($this->namespace) > 0) {
             $repositoryClassName = $this->namespace . '\\' . $repositoryClassName;
         }
@@ -1722,7 +1747,7 @@ class ClassMetadataInfo implements ClassMetadata
 
     /**
      * Return the single association join column (if any).
-     * 
+     *
      * @param string $fieldName
      * @return string
      */
@@ -1764,7 +1789,7 @@ class ClassMetadataInfo implements ClassMetadata
             foreach ($this->associationMappings AS $assocName => $mapping) {
                 if ($this->isAssociationWithSingleJoinColumn($assocName) &&
                     $this->associationMappings[$assocName]['joinColumns'][0]['name'] == $columnName) {
-                    
+
                     return $assocName;
                 }
             }
@@ -1854,34 +1879,34 @@ class ClassMetadataInfo implements ClassMetadata
     {
         $this->isReadOnly = true;
     }
-    
+
     /**
      * A numerically indexed list of field names of this persistent class.
-     * 
+     *
      * This array includes identifier fields if present on this class.
-     * 
+     *
      * @return array
      */
     public function getFieldNames()
     {
         return array_keys($this->fieldMappings);
     }
-    
+
     /**
      * A numerically indexed list of association names of this persistent class.
-     * 
+     *
      * This array includes identifier associations if present on this class.
-     * 
+     *
      * @return array
      */
     public function getAssociationNames()
     {
         return array_keys($this->associationMappings);
     }
-    
+
     /**
      * Returns the target class name of the given association.
-     * 
+     *
      * @param string $assocName
      * @return string
      */
@@ -1890,13 +1915,13 @@ class ClassMetadataInfo implements ClassMetadata
         if ( ! isset($this->associationMappings[$assocName])) {
             throw new \InvalidArgumentException("Association name expected, '" . $assocName ."' is not an association.");
         }
-        
+
         return $this->associationMappings[$assocName]['targetEntity'];
     }
-    
+
     /**
      * Get fully-qualified class name of this persistent class.
-     * 
+     *
      * @return string
      */
     public function getName()
@@ -1904,23 +1929,61 @@ class ClassMetadataInfo implements ClassMetadata
         return $this->name;
     }
 
+    /**
+     * Gets the (possibly quoted) identifier column names for safe use in an SQL statement.
+     *
+     * @param AbstractPlatform $platform
+     * @return array
+     */
+    public function getQuotedIdentifierColumnNames($platform)
+    {
+        $quotedColumnNames = array();
+
+        foreach ($this->identifier as $idProperty) {
+            if (isset($this->fieldMappings[$idProperty])) {
+                $quotedColumnNames[] = isset($this->fieldMappings[$idProperty]['quoted'])
+                    ? $platform->quoteIdentifier($this->fieldMappings[$idProperty]['columnName'])
+                    : $this->fieldMappings[$idProperty]['columnName'];
+
+                continue;
+            }
+
+            // Association defined as Id field
+            $joinColumns            = $this->associationMappings[$idProperty]['joinColumns'];
+            $assocQuotedColumnNames = array_map(
+                function ($joinColumn) {
+                    return isset($joinColumn['quoted'])
+                        ? $platform->quoteIdentifier($joinColumn['name'])
+                        : $joinColumn['name'];
+                },
+                $joinColumns
+            );
+
+            $quotedColumnNames = array_merge($quotedColumnNames, $assocQuotedColumnNames);
+        }
+
+        return $quotedColumnNames;
+    }
+
     /**
      * Gets the (possibly quoted) column name of a mapped field for safe use
      * in an SQL statement.
-     * 
+     *
      * @param string $field
      * @param AbstractPlatform $platform
      * @return string
      */
     public function getQuotedColumnName($field, $platform)
     {
-        return isset($this->fieldMappings[$field]['quoted']) ? $platform->quoteIdentifier($this->fieldMappings[$field]['columnName']) : $this->fieldMappings[$field]['columnName'];
+        return isset($this->fieldMappings[$field]['quoted'])
+            ? $platform->quoteIdentifier($this->fieldMappings[$field]['columnName'])
+            : $this->fieldMappings[$field]['columnName'];
     }
-    
+
     /**
      * Gets the (possibly quoted) primary table name of this class for safe use
      * in an SQL statement.
-     * 
+     *
      * @param AbstractPlatform $platform
      * @return string
      */
@@ -1939,4 +2002,22 @@ class ClassMetadataInfo implements ClassMetadata
     {
         return isset($assoc['joinTable']['quoted']) ? $platform->quoteIdentifier($assoc['joinTable']['name']) : $assoc['joinTable']['name'];
     }
+
+    /**
+     * @param string $fieldName
+     * @return bool
+     */
+    public function isAssociationInverseSide($fieldName)
+    {
+        return isset($this->associationMappings[$fieldName]) && ! $this->associationMappings[$fieldName]['isOwningSide'];
+    }
+
+    /**
+     * @param string $fieldName
+     * @return string
+     */
+    public function getAssociationMappedByTargetField($fieldName)
+    {
+        return $this->associationMappings[$fieldName]['mappedBy'];
+    }
 }

lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php

@@ -331,7 +331,7 @@ class AnnotationDriver implements Driver
                 $mapping['inversedBy'] = $oneToOneAnnot->inversedBy;
                 $mapping['cascade'] = $oneToOneAnnot->cascade;
                 $mapping['orphanRemoval'] = $oneToOneAnnot->orphanRemoval;
-                $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $oneToOneAnnot->fetch);
+                $mapping['fetch'] = $this->getFetchMode($className, $oneToOneAnnot->fetch);
                 $metadata->mapOneToOne($mapping);
             } else if ($oneToManyAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OneToMany')) {
                 $mapping['mappedBy'] = $oneToManyAnnot->mappedBy;
@@ -339,7 +339,7 @@ class AnnotationDriver implements Driver
                 $mapping['cascade'] = $oneToManyAnnot->cascade;
                 $mapping['indexBy'] = $oneToManyAnnot->indexBy;
                 $mapping['orphanRemoval'] = $oneToManyAnnot->orphanRemoval;
-                $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $oneToManyAnnot->fetch);
+                $mapping['fetch'] = $this->getFetchMode($className, $oneToManyAnnot->fetch);
 
                 if ($orderByAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OrderBy')) {
                     $mapping['orderBy'] = $orderByAnnot->value;
@@ -355,7 +355,7 @@ class AnnotationDriver implements Driver
                 $mapping['cascade'] = $manyToOneAnnot->cascade;
                 $mapping['inversedBy'] = $manyToOneAnnot->inversedBy;
                 $mapping['targetEntity'] = $manyToOneAnnot->targetEntity;
-                $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $manyToOneAnnot->fetch);
+                $mapping['fetch'] = $this->getFetchMode($className, $manyToOneAnnot->fetch);
                 $metadata->mapManyToOne($mapping);
             } else if ($manyToManyAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\ManyToMany')) {
                 $joinTable = array();
@@ -395,7 +395,7 @@ class AnnotationDriver implements Driver
                 $mapping['inversedBy'] = $manyToManyAnnot->inversedBy;
                 $mapping['cascade'] = $manyToManyAnnot->cascade;
                 $mapping['indexBy'] = $manyToManyAnnot->indexBy;
-                $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $manyToManyAnnot->fetch);
+                $mapping['fetch'] = $this->getFetchMode($className, $manyToManyAnnot->fetch);
 
                 if ($orderByAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OrderBy')) {
                     $mapping['orderBy'] = $orderByAnnot->value;
@@ -446,6 +446,10 @@ class AnnotationDriver implements Driver
                     if (isset($annotations['Doctrine\ORM\Mapping\PostLoad'])) {
                         $metadata->addLifecycleCallback($method->getName(), \Doctrine\ORM\Events::postLoad);
                     }
+
+                    if (isset($annotations['Doctrine\ORM\Mapping\PreFlush'])) {
+                        $metadata->addLifecycleCallback($method->getName(), \Doctrine\ORM\Events::preFlush);
+                    }
                 }
             }
         }
@@ -536,6 +540,22 @@ class AnnotationDriver implements Driver
         return $classes;
     }
 
+    /**
+     * Attempts to resolve the fetch mode.
+     *
+     * @param string $className The class name
+     * @param string $fetchMode The fetch mode
+     * @return integer The fetch mode as defined in ClassMetadata
+     * @throws MappingException If the fetch mode is not valid
+     */
+    private function getFetchMode($className, $fetchMode)
+    {
+        if(!defined('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode)) {
+            throw MappingException::invalidFetchMode($className,  $fetchMode);
+        }
+
+        return constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode);
+    }
     /**
      * Factory method for the Annotation Driver
      *

lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php

@@ -387,3 +387,9 @@ final class PostRemove implements Annotation {}
  * @Target("METHOD")
  */
 final class PostLoad implements Annotation {}
+
+/**
+ * @Annotation
+ * @Target("METHOD")
+ */
+final class PreFlush implements Annotation {}

lib/Doctrine/ORM/Mapping/Driver/XmlDriver.php

@@ -89,7 +89,7 @@ class XmlDriver extends AbstractFileDriver
         if (isset($xmlRoot['schema'])) {
             $metadata->table['schema'] = (string)$xmlRoot['schema'];
         }*/
-        
+
         if (isset($xmlRoot['inheritance-type'])) {
             $inheritanceType = (string)$xmlRoot['inheritance-type'];
             $metadata->setInheritanceType(constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . $inheritanceType));
@@ -166,9 +166,12 @@ class XmlDriver extends AbstractFileDriver
             foreach ($xmlRoot->field as $fieldMapping) {
                 $mapping = array(
                     'fieldName' => (string)$fieldMapping['name'],
-                    'type' => (string)$fieldMapping['type']
                 );
 
+                if (isset($fieldMapping['type'])) {
+                    $mapping['type'] = (string)$fieldMapping['type'];
+                }
+
                 if (isset($fieldMapping['column'])) {
                     $mapping['columnName'] = (string)$fieldMapping['column'];
                 }
@@ -219,10 +222,13 @@ class XmlDriver extends AbstractFileDriver
 
             $mapping = array(
                 'id' => true,
-                'fieldName' => (string)$idElement['name'],
-                'type' => (string)$idElement['type']
+                'fieldName' => (string)$idElement['name']
             );
 
+            if (isset($idElement['type'])) {
+                $mapping['type'] = (string)$idElement['type'];
+            }
+
             if (isset($idElement['column'])) {
                 $mapping['columnName'] = (string)$idElement['column'];
             }
@@ -327,6 +333,8 @@ class XmlDriver extends AbstractFileDriver
 
                 if (isset($oneToManyElement['index-by'])) {
                     $mapping['indexBy'] = (string)$oneToManyElement['index-by'];
+                } else if (isset($oneToManyElement->{'index-by'})) {
+                    throw new \InvalidArgumentException("<index-by /> is not a valid tag");
                 }
 
                 $metadata->mapOneToMany($mapping);
@@ -369,10 +377,6 @@ class XmlDriver extends AbstractFileDriver
                     $mapping['cascade'] = $this->_getCascadeMappings($manyToOneElement->cascade);
                 }
 
-                if (isset($manyToOneElement->{'orphan-removal'})) {
-                    $mapping['orphanRemoval'] = (bool)$manyToOneElement->{'orphan-removal'};
-                }
-
                 $metadata->mapManyToOne($mapping);
             }
         }
@@ -420,10 +424,6 @@ class XmlDriver extends AbstractFileDriver
                     $mapping['cascade'] = $this->_getCascadeMappings($manyToManyElement->cascade);
                 }
 
-                if (isset($manyToManyElement->{'orphan-removal'})) {
-                    $mapping['orphanRemoval'] = (bool)$manyToManyElement->{'orphan-removal'};
-                }
-
                 if (isset($manyToManyElement->{'order-by'})) {
                     $orderBy = array();
                     foreach ($manyToManyElement->{'order-by'}->{'order-by-field'} AS $orderByField) {
@@ -432,8 +432,10 @@ class XmlDriver extends AbstractFileDriver
                     $mapping['orderBy'] = $orderBy;
                 }
 
-                if (isset($manyToManyElement->{'index-by'})) {
-                    $mapping['indexBy'] = (string)$manyToManyElement->{'index-by'};
+                if (isset($manyToManyElement['index-by'])) {
+                    $mapping['indexBy'] = (string)$manyToManyElement['index-by'];
+                } else if (isset($manyToManyElement->{'index-by'})) {
+                    throw new \InvalidArgumentException("<index-by /> is not a valid tag");
                 }
 
                 $metadata->mapManyToMany($mapping);

lib/Doctrine/ORM/Mapping/Driver/YamlDriver.php

@@ -47,7 +47,7 @@ class YamlDriver extends AbstractFileDriver
 
         if ($element['type'] == 'entity') {
             if (isset($element['repositoryClass'])) {
-                $metadata->setCustomRepositoryClass($element['repositoryClass']);  
+                $metadata->setCustomRepositoryClass($element['repositoryClass']);
             }
             if (isset($element['readOnly']) && $element['readOnly'] == true) {
                 $metadata->markReadOnly();
@@ -165,16 +165,15 @@ class YamlDriver extends AbstractFileDriver
                     continue;
                 }
 
-                if (!isset($idElement['type'])) {
-                    throw MappingException::propertyTypeIsRequired($className, $name);
-                }
-
                 $mapping = array(
                     'id' => true,
-                    'fieldName' => $name,
-                    'type' => $idElement['type']
+                    'fieldName' => $name
                 );
 
+                if (isset($idElement['type'])) {
+                    $mapping['type'] = $idElement['type'];
+                }
+
                 if (isset($idElement['column'])) {
                     $mapping['columnName'] = $idElement['column'];
                 }
@@ -201,19 +200,21 @@ class YamlDriver extends AbstractFileDriver
         // Evaluate fields
         if (isset($element['fields'])) {
             foreach ($element['fields'] as $name => $fieldMapping) {
-                if (!isset($fieldMapping['type'])) {
-                    throw MappingException::propertyTypeIsRequired($className, $name);
+
+                $mapping = array(
+                    'fieldName' => $name
+                );
+
+                if (isset($fieldMapping['type'])) {
+                    $e = explode('(', $fieldMapping['type']);
+                    $fieldMapping['type'] = $e[0];
+                    $mapping['type']      = $fieldMapping['type'];
+
+                    if (isset($e[1])) {
+                        $fieldMapping['length'] = substr($e[1], 0, strlen($e[1]) - 1);
+                    }
                 }
 
-                $e = explode('(', $fieldMapping['type']);
-                $fieldMapping['type'] = $e[0];
-                if (isset($e[1])) {
-                    $fieldMapping['length'] = substr($e[1], 0, strlen($e[1]) - 1);
-                }
-                $mapping = array(
-                    'fieldName' => $name,
-                    'type' => $fieldMapping['type']
-                );
                 if (isset($fieldMapping['id'])) {
                     $mapping['id'] = true;
                     if (isset($fieldMapping['generator']['strategy'])) {
@@ -378,10 +379,6 @@ class YamlDriver extends AbstractFileDriver
                     $mapping['cascade'] = $manyToOneElement['cascade'];
                 }
 
-                if (isset($manyToOneElement['orphanRemoval'])) {
-                    $mapping['orphanRemoval'] = (bool)$manyToOneElement['orphanRemoval'];
-                }
-
                 $metadata->mapManyToOne($mapping);
             }
         }
@@ -437,10 +434,6 @@ class YamlDriver extends AbstractFileDriver
                     $mapping['cascade'] = $manyToManyElement['cascade'];
                 }
 
-                if (isset($manyToManyElement['orphanRemoval'])) {
-                    $mapping['orphanRemoval'] = (bool)$manyToManyElement['orphanRemoval'];
-                }
-
                 if (isset($manyToManyElement['orderBy'])) {
                     $mapping['orderBy'] = $manyToManyElement['orderBy'];
                 }

lib/Doctrine/ORM/Mapping/MappingException.php

@@ -184,7 +184,7 @@ class MappingException extends \Doctrine\ORM\ORMException
         if ( ! empty($path)) {
             $path = '[' . $path . ']';
         }
-        
+
         return new self(
             'File mapping drivers must have a valid directory path, ' .
             'however the given path ' . $path . ' seems to be incorrect!'
@@ -226,6 +226,11 @@ class MappingException extends \Doctrine\ORM\ORMException
         return new self("Setting Id field '$fieldName' as versionale in entity class '$className' is not supported.");
     }
 
+    public static function sqlConversionNotAllowedForIdentifiers($className, $fieldName, $type)
+    {
+        return new self("It is not possible to set id field '$fieldName' to type '$type' in entity class '$className'. The type '$type' requires conversion SQL which is not allowed for identifiers.");
+    }
+
     /**
      * @param  string $className
      * @param  string $columnName
@@ -270,6 +275,12 @@ class MappingException extends \Doctrine\ORM\ORMException
             "part of the identifier in '$className#$field'.");
     }
 
+    public static function illegalOrphanRemoval($className, $field)
+    {
+        return new self("Orphan removal is only allowed on one-to-one and one-to-many ".
+                "associations, but " . $className."#" .$field . " is not.");
+    }
+
     public static function illegalInverseIdentifierAssocation($className, $field)
     {
         return new self("An inverse association is not allowed to be identifier in '$className#$field'.");
@@ -279,16 +290,16 @@ class MappingException extends \Doctrine\ORM\ORMException
     {
         return new self("Many-to-many or one-to-many associations are not allowed to be identifier in '$className#$field'.");
     }
-    
+
     public static function noInheritanceOnMappedSuperClass($className)
     {
         return new self("Its not supported to define inheritance information on a mapped superclass '" . $className . "'.");
     }
-    
+
     public static function mappedClassNotPartOfDiscriminatorMap($className, $rootClassName)
     {
         return new self(
-            "Entity '" . $className . "' has to be part of the descriminator map of '" . $rootClassName . "' " .
+            "Entity '" . $className . "' has to be part of the discriminator map of '" . $rootClassName . "' " .
             "to be properly mapped in the inheritance hierachy. Alternatively you can make '".$className."' an abstract class " .
             "to avoid this exception from occuring."
         );
@@ -298,4 +309,9 @@ class MappingException extends \Doctrine\ORM\ORMException
     {
         return new self("Entity '" . $className . "' has no method '" . $methodName . "' to be registered as lifecycle callback.");
     }
-}
+
+    public static function invalidFetchMode($className, $annotation)
+    {
+        return new self("Entity '" . $className . "' has a mapping with invalid fetch mode '" . $annotation . "'");
+    }
+}

lib/Doctrine/ORM/NativeQuery.php

@@ -57,17 +57,17 @@ final class NativeQuery extends AbstractQuery
      */
     protected function _doExecute()
     {
-        $stmt = $this->_em->getConnection()->prepare($this->_sql);
         $params = $this->_params;
-        foreach ($params as $key => $value) {
-            if (isset($this->_paramTypes[$key])) {
-                $stmt->bindValue($key, $value, $this->_paramTypes[$key]);
-            } else {
-                $stmt->bindValue($key, $value);
+        $types = $this->_paramTypes;
+        if ($params) {
+            if (is_int(key($params))) {
+                ksort($params);
+                ksort($types);
+                $params = array_values($params);
+                $types = array_values($types);
             }
         }
-        $stmt->execute();
 
-        return $stmt;
+        return $this->_em->getConnection()->executeQuery($this->_sql, $params, $types, $this->_queryCacheProfile);
     }
 }

lib/Doctrine/ORM/ORMException.php

@@ -59,6 +59,15 @@ class ORMException extends Exception
         return new self("Unrecognized field: $field");
     }
 
+    /**
+     * @param string $className
+     * @param string $field
+     */
+    public static function invalidOrientation($className, $field)
+    {
+        return new self("Invalid order by orientation specified for " . $className . "#" . $field);
+    }
+
     public static function invalidFlushMode($mode)
     {
         return new self("'$mode' is an invalid flush mode.");

lib/Doctrine/ORM/PersistentCollection.php

@@ -93,21 +93,21 @@ final class PersistentCollection implements Collection
 
     /**
      * Whether the collection has already been initialized.
-     * 
+     *
      * @var boolean
      */
     private $initialized = true;
-    
+
     /**
      * The wrapped Collection instance.
-     * 
+     *
      * @var Collection
      */
     private $coll;
 
     /**
      * Creates a new persistent collection.
-     * 
+     *
      * @param EntityManager $em The EntityManager the collection will be associated with.
      * @param ClassMetadata $class The class descriptor of the entity type of this collection.
      * @param array The collection elements.
@@ -144,7 +144,7 @@ final class PersistentCollection implements Collection
     {
         return $this->owner;
     }
-    
+
     public function getTypeClass()
     {
         return $this->typeClass;
@@ -154,7 +154,7 @@ final class PersistentCollection implements Collection
      * INTERNAL:
      * Adds an element to a collection during hydration. This will automatically
      * complete bidirectional associations in the case of a one-to-many association.
-     * 
+     *
      * @param mixed $element The element to add.
      */
     public function hydrateAdd($element)
@@ -172,7 +172,7 @@ final class PersistentCollection implements Collection
                     $this->owner);
         }
     }
-    
+
     /**
      * INTERNAL:
      * Sets a keyed element in the collection during hydration.
@@ -271,7 +271,7 @@ final class PersistentCollection implements Collection
     {
         return $this->association;
     }
-   
+
     /**
      * Marks this collection as changed/dirty.
      */
@@ -306,17 +306,17 @@ final class PersistentCollection implements Collection
     {
         $this->isDirty = $dirty;
     }
-    
+
     /**
      * Sets the initialized flag of the collection, forcing it into that state.
-     * 
+     *
      * @param boolean $bool
      */
     public function setInitialized($bool)
     {
         $this->initialized = $bool;
     }
-    
+
     /**
      * Checks whether this collection has been initialized.
      *
@@ -377,7 +377,7 @@ final class PersistentCollection implements Collection
             $this->em->getUnitOfWork()->getCollectionPersister($this->association)
                 ->deleteRows($this, $element);
         }*/
-        
+
         $this->initialize();
         $removed = $this->coll->removeElement($element);
         if ($removed) {
@@ -410,7 +410,7 @@ final class PersistentCollection implements Collection
                             ->getCollectionPersister($this->association)
                             ->contains($this, $element);
         }
-        
+
         $this->initialize();
         return $this->coll->contains($element);
     }
@@ -468,7 +468,7 @@ final class PersistentCollection implements Collection
         if (!$this->initialized && $this->association['fetch'] == Mapping\ClassMetadataInfo::FETCH_EXTRA_LAZY) {
             return $this->em->getUnitOfWork()
                         ->getCollectionPersister($this->association)
-                        ->count($this) + $this->coll->count();
+                        ->count($this) + ($this->isDirty ? $this->coll->count() : 0);
         }
 
         $this->initialize();
@@ -503,7 +503,7 @@ final class PersistentCollection implements Collection
         $this->initialize();
         return $this->coll->isEmpty();
     }
-    
+
     /**
      * {@inheritdoc}
      */
@@ -530,7 +530,7 @@ final class PersistentCollection implements Collection
         $this->initialize();
         return $this->coll->filter($p);
     }
-    
+
     /**
      * {@inheritdoc}
      */
@@ -548,7 +548,7 @@ final class PersistentCollection implements Collection
         $this->initialize();
         return $this->coll->partition($p);
     }
-    
+
     /**
      * {@inheritdoc}
      */
@@ -567,6 +567,9 @@ final class PersistentCollection implements Collection
             return;
         }
         if ($this->association['type'] == ClassMetadata::ONE_TO_MANY && $this->association['orphanRemoval']) {
+            // we need to initialize here, as orphan removal acts like implicit cascadeRemove,
+            // hence for event listeners we need the objects in memory.
+            $this->initialize();
             foreach ($this->coll as $element) {
                 $this->em->getUnitOfWork()->scheduleOrphanRemoval($element);
             }
@@ -579,7 +582,7 @@ final class PersistentCollection implements Collection
             $this->takeSnapshot();
         }
     }
-    
+
     /**
      * Called by PHP when this collection is serialized. Ensures that only the
      * elements are properly serialized.
@@ -591,7 +594,7 @@ final class PersistentCollection implements Collection
     {
         return array('coll', 'initialized');
     }
-    
+
     /* ArrayAccess implementation */
 
     /**
@@ -629,12 +632,12 @@ final class PersistentCollection implements Collection
     {
         return $this->remove($offset);
     }
-    
+
     public function key()
     {
         return $this->coll->key();
     }
-    
+
     /**
      * Gets the element of the collection at the current iterator position.
      */
@@ -642,7 +645,7 @@ final class PersistentCollection implements Collection
     {
         return $this->coll->current();
     }
-    
+
     /**
      * Moves the internal iterator position to the next element.
      */
@@ -650,7 +653,7 @@ final class PersistentCollection implements Collection
     {
         return $this->coll->next();
     }
-    
+
     /**
      * Retrieves the wrapped Collection instance.
      */
@@ -672,7 +675,10 @@ final class PersistentCollection implements Collection
      */
     public function slice($offset, $length = null)
     {
-        if (!$this->initialized && $this->association['fetch'] == Mapping\ClassMetadataInfo::FETCH_EXTRA_LAZY) {
+        if ( ! $this->initialized &&
+             ! $this->isDirty &&
+               $this->association['fetch'] == Mapping\ClassMetadataInfo::FETCH_EXTRA_LAZY) {
+
             return $this->em->getUnitOfWork()
                             ->getCollectionPersister($this->association)
                             ->slice($this, $offset, $length);

lib/Doctrine/ORM/Persisters/AbstractEntityInheritancePersister.php

@@ -62,18 +62,22 @@ abstract class AbstractEntityInheritancePersister extends BasicEntityPersister
     {
         $columnName = $class->columnNames[$field];
         $sql = $this->_getSQLTableAlias($class->name, $alias == 'r' ? '' : $alias) . '.' . $class->getQuotedColumnName($field, $this->_platform);
-        $columnAlias = $this->_platform->getSQLResultCasing($columnName . $this->_sqlAliasCounter++);
+        $columnAlias = $this->getSQLColumnAlias($columnName);
         $this->_rsm->addFieldResult($alias, $columnAlias, $field, $class->name);
 
+        if (isset($class->fieldMappings[$field]['requireSQLConversion'])) {
+            $type = Type::getType($class->getTypeOfField($field));
+            $sql = $type->convertToPHPValueSQL($sql, $this->_platform);
+        }
+
         return $sql . ' AS ' . $columnAlias;
     }
 
     protected function getSelectJoinColumnSQL($tableAlias, $joinColumnName, $className)
     {
-        $columnAlias = $joinColumnName . $this->_sqlAliasCounter++;
-        $resultColumnName = $this->_platform->getSQLResultCasing($columnAlias);
-        $this->_rsm->addMetaResult('r', $resultColumnName, $joinColumnName);
+        $columnAlias = $this->getSQLColumnAlias($joinColumnName);
+        $this->_rsm->addMetaResult('r', $columnAlias, $joinColumnName);
         
         return $tableAlias . '.' . $joinColumnName . ' AS ' . $columnAlias;
     }
-}
+}

lib/Doctrine/ORM/Persisters/JoinedSubclassPersister.php

@@ -46,7 +46,7 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
 
     /**
      * Map of table to quoted table names.
-     * 
+     *
      * @var array
      */
     private $_quotedTableMap = array();
@@ -59,7 +59,7 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
         $class = ($this->_class->name !== $this->_class->rootEntityName)
             ? $this->_em->getClassMetadata($this->_class->rootEntityName)
             : $this->_class;
-        
+
         return $class->getTableName();
     }
 
@@ -73,10 +73,10 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
     {
         if (isset($this->_class->fieldMappings[$this->_class->versionField]['inherited'])) {
             $definingClassName = $this->_class->fieldMappings[$this->_class->versionField]['inherited'];
-            
+
             return $this->_em->getClassMetadata($definingClassName);
         }
-        
+
         return $this->_class;
     }
 
@@ -92,7 +92,7 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
         if (isset($this->_owningTableMap[$fieldName])) {
             return $this->_owningTableMap[$fieldName];
         }
-        
+
         if (isset($this->_class->associationMappings[$fieldName]['inherited'])) {
             $cm = $this->_em->getClassMetadata($this->_class->associationMappings[$fieldName]['inherited']);
         } else if (isset($this->_class->fieldMappings[$fieldName]['inherited'])) {
@@ -130,15 +130,15 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
 
         // Prepare statements for sub tables.
         $subTableStmts = array();
-        
+
         if ($rootClass !== $this->_class) {
             $subTableStmts[$this->_class->getTableName()] = $this->_conn->prepare($this->_getInsertSQL());
         }
-        
+
         foreach ($this->_class->parentClasses as $parentClassName) {
             $parentClass = $this->_em->getClassMetadata($parentClassName);
             $parentTableName = $parentClass->getTableName();
-            
+
             if ($parentClass !== $rootClass) {
                 $parentPersister = $this->_em->getUnitOfWork()->getEntityPersister($parentClassName);
                 $subTableStmts[$parentTableName] = $this->_conn->prepare($parentPersister->_getInsertSQL());
@@ -153,11 +153,11 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
 
             // Execute insert on root table
             $paramIndex = 1;
-            
+
             foreach ($insertData[$rootTableName] as $columnName => $value) {
                 $rootTableStmt->bindValue($paramIndex++, $value, $this->_columnTypes[$columnName]);
             }
-            
+
             $rootTableStmt->execute();
 
             if ($isPostInsertId) {
@@ -172,23 +172,23 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
             foreach ($subTableStmts as $tableName => $stmt) {
                 $data = isset($insertData[$tableName]) ? $insertData[$tableName] : array();
                 $paramIndex = 1;
-                
+
                 foreach ((array) $id as $idName => $idVal) {
                     $type = isset($this->_columnTypes[$idName]) ? $this->_columnTypes[$idName] : Type::STRING;
-                    
+
                     $stmt->bindValue($paramIndex++, $idVal, $type);
                 }
-                
+
                 foreach ($data as $columnName => $value) {
                     $stmt->bindValue($paramIndex++, $value, $this->_columnTypes[$columnName]);
                 }
-                
+
                 $stmt->execute();
             }
         }
 
         $rootTableStmt->closeCursor();
-        
+
         foreach ($subTableStmts as $stmt) {
             $stmt->closeCursor();
         }
@@ -220,7 +220,7 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
                     $entity, $this->_quotedTableMap[$tableName], $data, $isVersioned && $versionedTable == $tableName
                 );
             }
-            
+
             // Make sure the table with the version column is updated even if no columns on that
             // table were affected.
             if ($isVersioned && ! isset($updateData[$versionedTable])) {
@@ -251,7 +251,7 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
         } else {
             // Delete from all tables individually, starting from this class' table up to the root table.
             $this->_conn->delete($this->_class->getQuotedTableName($this->_platform), $id);
-            
+
             foreach ($this->_class->parentClasses as $parentClass) {
                 $this->_conn->delete(
                     $this->_em->getClassMetadata($parentClass)->getQuotedTableName($this->_platform), $id
@@ -270,16 +270,16 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
 
         // Create the column list fragment only once
         if ($this->_selectColumnListSql === null) {
-            
+
             $this->_rsm = new ResultSetMapping();
             $this->_rsm->addEntityResult($this->_class->name, 'r');
-            
+
             // Add regular columns
             $columnList = '';
-            
+
             foreach ($this->_class->fieldMappings as $fieldName => $mapping) {
                 if ($columnList != '') $columnList .= ', ';
-                
+
                 $columnList .= $this->_getSelectColumnSQL(
                     $fieldName,
                     isset($mapping['inherited']) ? $this->_em->getClassMetadata($mapping['inherited']) : $this->_class
@@ -290,12 +290,12 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
             foreach ($this->_class->associationMappings as $assoc2) {
                 if ($assoc2['isOwningSide'] && $assoc2['type'] & ClassMetadata::TO_ONE) {
                     $tableAlias = isset($assoc2['inherited']) ? $this->_getSQLTableAlias($assoc2['inherited']) : $baseTableAlias;
-                    
+
                     foreach ($assoc2['targetToSourceKeyColumns'] as $srcColumn) {
                         if ($columnList != '') $columnList .= ', ';
-                        
+
                         $columnList .= $this->getSelectJoinColumnSQL(
-                            $tableAlias, 
+                            $tableAlias,
                             $srcColumn,
                             isset($assoc2['inherited']) ? $assoc2['inherited'] : $this->_class->name
                         );
@@ -309,23 +309,23 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
             $columnList .= ', ' . $tableAlias . '.' . $discrColumn;
 
             $resultColumnName = $this->_platform->getSQLResultCasing($discrColumn);
-            
+
             $this->_rsm->setDiscriminatorColumn('r', $resultColumnName);
             $this->_rsm->addMetaResult('r', $resultColumnName, $discrColumn);
         }
 
         // INNER JOIN parent tables
         $joinSql = '';
-        
+
         foreach ($this->_class->parentClasses as $parentClassName) {
             $parentClass = $this->_em->getClassMetadata($parentClassName);
             $tableAlias = $this->_getSQLTableAlias($parentClassName);
             $joinSql .= ' INNER JOIN ' . $parentClass->getQuotedTableName($this->_platform) . ' ' . $tableAlias . ' ON ';
             $first = true;
-            
+
             foreach ($idColumns as $idColumn) {
                 if ($first) $first = false; else $joinSql .= ' AND ';
-                
+
                 $joinSql .= $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
             }
         }
@@ -339,7 +339,7 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
                 // Add subclass columns
                 foreach ($subClass->fieldMappings as $fieldName => $mapping) {
                     if (isset($mapping['inherited'])) continue;
-                    
+
                     $columnList .= ', ' . $this->_getSelectColumnSQL($fieldName, $subClass);
                 }
 
@@ -348,9 +348,9 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
                     if ($assoc2['isOwningSide'] && $assoc2['type'] & ClassMetadata::TO_ONE && ! isset($assoc2['inherited'])) {
                         foreach ($assoc2['targetToSourceKeyColumns'] as $srcColumn) {
                             if ($columnList != '') $columnList .= ', ';
-                            
+
                             $columnList .= $this->getSelectJoinColumnSQL(
-                                $tableAlias, 
+                                $tableAlias,
                                 $srcColumn,
                                 isset($assoc2['inherited']) ? $assoc2['inherited'] : $subClass->name
                             );
@@ -362,10 +362,10 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
             // Add LEFT JOIN
             $joinSql .= ' LEFT JOIN ' . $subClass->getQuotedTableName($this->_platform) . ' ' . $tableAlias . ' ON ';
             $first = true;
-            
+
             foreach ($idColumns as $idColumn) {
                 if ($first) $first = false; else $joinSql .= ' AND ';
-                
+
                 $joinSql .= $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
             }
         }
@@ -382,7 +382,7 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
         }
 
         $lockSql = '';
-        
+
         if ($lockMode == LockMode::PESSIMISTIC_READ) {
             $lockSql = ' ' . $this->_platform->getReadLockSql();
         } else if ($lockMode == LockMode::PESSIMISTIC_WRITE) {
@@ -408,29 +408,29 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
 
         // INNER JOIN parent tables
         $joinSql = '';
-        
+
         foreach ($this->_class->parentClasses as $parentClassName) {
             $parentClass = $this->_em->getClassMetadata($parentClassName);
             $tableAlias = $this->_getSQLTableAlias($parentClassName);
             $joinSql .= ' INNER JOIN ' . $parentClass->getQuotedTableName($this->_platform) . ' ' . $tableAlias . ' ON ';
             $first = true;
-            
+
             foreach ($idColumns as $idColumn) {
                 if ($first) $first = false; else $joinSql .= ' AND ';
-                
+
                 $joinSql .= $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
             }
         }
 
         return 'FROM ' . $this->_class->getQuotedTableName($this->_platform) . ' ' . $baseTableAlias . $joinSql;
     }
-    
+
     /* Ensure this method is never called. This persister overrides _getSelectEntitiesSQL directly. */
     protected function _getSelectColumnListSQL()
     {
         throw new \BadMethodCallException("Illegal invocation of ".__METHOD__.".");
     }
-    
+
     /** {@inheritdoc} */
     protected function _getInsertColumnList()
     {

lib/Doctrine/ORM/Persisters/SingleTablePersister.php

@@ -131,4 +131,4 @@ class SingleTablePersister extends AbstractEntityInheritancePersister
 
         return $conditionSql;
     }
-}
+}

lib/Doctrine/ORM/Proxy/ProxyFactory.php

@@ -165,11 +165,13 @@ class ProxyFactory
     {
         $methods = '';
 
+        $methodNames = array();
         foreach ($class->reflClass->getMethods() as $method) {
             /* @var $method ReflectionMethod */
-            if ($method->isConstructor() || in_array(strtolower($method->getName()), array("__sleep", "__clone"))) {
+            if ($method->isConstructor() || in_array(strtolower($method->getName()), array("__sleep", "__clone")) || isset($methodNames[$method->getName()])) {
                 continue;
             }
+            $methodNames[$method->getName()] = true;
 
             if ($method->isPublic() && ! $method->isFinal() && ! $method->isStatic()) {
                 $methods .= "\n" . '    public function ';
@@ -210,8 +212,12 @@ class ProxyFactory
                 $methods .= $parameterString . ')';
                 $methods .= "\n" . '    {' . "\n";
                 if ($this->isShortIdentifierGetter($method, $class)) {
+                    $identifier = lcfirst(substr($method->getName(), 3));
+
+                    $cast = in_array($class->fieldMappings[$identifier]['type'], array('integer', 'smallint')) ? '(int) ' : '';
+
                     $methods .= '        if ($this->__isInitialized__ === false) {' . "\n";
-                    $methods .= '            return $this->_identifier["' . lcfirst(substr($method->getName(), 3)) . '"];' . "\n";
+                    $methods .= '            return ' . $cast . '$this->_identifier["' . $identifier . '"];' . "\n";
                     $methods .= '        }' . "\n";
                 }
                 $methods .= '        $this->__load();' . "\n";
@@ -230,13 +236,14 @@ class ProxyFactory
      */
     private function isShortIdentifierGetter($method, $class)
     {
-        $identifier = lcfirst(substr($method->getName(), 3)); 
+        $identifier = lcfirst(substr($method->getName(), 3));
         return (
             $method->getNumberOfParameters() == 0 &&
             substr($method->getName(), 0, 3) == "get" &&
             in_array($identifier, $class->identifier, true) &&
             $class->hasField($identifier) &&
             (($method->getEndLine() - $method->getStartLine()) <= 4)
+            && in_array($class->fieldMappings[$identifier]['type'], array('integer', 'bigint', 'smallint', 'string'))
         );
     }
 

lib/Doctrine/ORM/Query.php

@@ -44,28 +44,28 @@ final class Query extends AbstractQuery
      * is called.
      */
     const STATE_DIRTY = 2;
-    
+
     /* Query HINTS */
     /**
      * The refresh hint turns any query into a refresh query with the result that
      * any local changes in entities are overridden with the fetched values.
-     * 
+     *
      * @var string
      */
     const HINT_REFRESH = 'doctrine.refresh';
-    
-    
+
+
     /**
      * Internal hint: is set to the proxy entity that is currently triggered for loading
-     * 
+     *
      * @var string
      */
     const HINT_REFRESH_ENTITY = 'doctrine.refresh.entity';
-    
+
     /**
      * The forcePartialLoad query hint forces a particular query to return
      * partial objects.
-     * 
+     *
      * @var string
      * @todo Rename: HINT_OPTIMIZE
      */
@@ -73,9 +73,9 @@ final class Query extends AbstractQuery
     /**
      * The includeMetaColumns query hint causes meta columns like foreign keys and
      * discriminator columns to be selected and returned as part of the query result.
-     * 
+     *
      * This hint does only apply to non-object queries.
-     * 
+     *
      * @var string
      */
     const HINT_INCLUDE_META_COLUMNS = 'doctrine.includeMetaColumns';
@@ -122,12 +122,12 @@ final class Query extends AbstractQuery
      * @var Doctrine\ORM\Query\ParserResult  The parser result that holds DQL => SQL information.
      */
     private $_parserResult;
-    
+
     /**
      * @var integer The first result to return (the "offset").
      */
     private $_firstResult = null;
-    
+
     /**
      * @var integer The maximum number of results to return (the "limit").
      */
@@ -147,7 +147,7 @@ final class Query extends AbstractQuery
      * @var int Query Cache lifetime.
      */
     private $_queryCacheTTL;
-    
+
     /**
      * @var boolean Whether to use a query cache, if available. Defaults to TRUE.
      */
@@ -191,7 +191,7 @@ final class Query extends AbstractQuery
 
     /**
      * Parses the DQL query, if necessary, and stores the parser result.
-     * 
+     *
      * Note: Populates $this->_parserResult as a side-effect.
      *
      * @return Doctrine\ORM\Query\ParserResult
@@ -209,7 +209,7 @@ final class Query extends AbstractQuery
         if ($this->_useQueryCache && ($queryCache = $this->getQueryCacheDriver())) {
             $hash   = $this->_getQueryCacheId();
             $cached = $this->_expireQueryCache ? false : $queryCache->fetch($hash);
-            
+
             if ($cached === false) {
                 // Cache miss.
                 $parser = new Parser($this);
@@ -223,9 +223,9 @@ final class Query extends AbstractQuery
             $parser = new Parser($this);
             $this->_parserResult = $parser->parse();
         }
-        
+
         $this->_state = self::STATE_CLEAN;
-        
+
         return $this->_parserResult;
     }
 
@@ -235,6 +235,9 @@ final class Query extends AbstractQuery
     protected function _doExecute()
     {
         $executor = $this->_parse()->getSqlExecutor();
+        if ($this->_queryCacheProfile) {
+            $executor->setQueryCacheProfile($this->_queryCacheProfile);
+        }
 
         // Prepare parameters
         $paramMappings = $this->_parserResult->getParameterMappings();
@@ -244,55 +247,62 @@ final class Query extends AbstractQuery
         }
 
         list($sqlParams, $types) = $this->processParameterMappings($paramMappings);
-        
+
         if ($this->_resultSetMapping === null) {
             $this->_resultSetMapping = $this->_parserResult->getResultSetMapping();
         }
 
         return $executor->execute($this->_em->getConnection(), $sqlParams, $types);
     }
-    
+
     /**
      * Processes query parameter mappings
-     * 
+     *
      * @param array $paramMappings
      * @return array
      */
     private function processParameterMappings($paramMappings)
     {
         $sqlParams = $types = array();
-        
+
         foreach ($this->_params as $key => $value) {
             if ( ! isset($paramMappings[$key])) {
                 throw QueryException::unknownParameter($key);
             }
-            
+
             if (isset($this->_paramTypes[$key])) {
                 foreach ($paramMappings[$key] as $position) {
                     $types[$position] = $this->_paramTypes[$key];
                 }
             }
-            
+
             $sqlPositions = $paramMappings[$key];
             $value = array_values($this->processParameterValue($value));
             $countValue = count($value);
-            
+
             for ($i = 0, $l = count($sqlPositions); $i < $l; $i++) {
                 $sqlParams[$sqlPositions[$i]] = $value[($i % $countValue)];
             }
         }
-        
+
+        if (count($sqlParams) != count($types)) {
+            throw QueryException::parameterTypeMissmatch();
+        }
+
         if ($sqlParams) {
             ksort($sqlParams);
             $sqlParams = array_values($sqlParams);
+
+            ksort($types);
+            $types = array_values($types);
         }
 
         return array($sqlParams, $types);
     }
-    
+
     /**
      * Process an individual parameter value
-     * 
+     *
      * @param mixed $value
      * @return array
      */
@@ -308,7 +318,7 @@ final class Query extends AbstractQuery
                 }
 
                 return array($value);
-                
+
             case is_object($value) && $this->_em->getMetadataFactory()->hasMetadataFor(get_class($value)):
                 if ($this->_em->getUnitOfWork()->getEntityState($value) === UnitOfWork::STATE_MANAGED) {
                     return array_values($this->_em->getUnitOfWork()->getEntityIdentifier($value));
@@ -317,7 +327,7 @@ final class Query extends AbstractQuery
                 $class = $this->_em->getClassMetadata(get_class($value));
 
                 return array_values($class->getIdentifierValues($value));
-                
+
             default:
                 return array($value);
         }
@@ -334,10 +344,10 @@ final class Query extends AbstractQuery
         $this->_queryCache = $queryCache;
         return $this;
     }
-    
+
     /**
      * Defines whether the query should make use of a query cache, if available.
-     * 
+     *
      * @param boolean $bool
      * @return @return Query This query instance.
      */
@@ -471,7 +481,7 @@ final class Query extends AbstractQuery
     {
         return stripos($this->getDQL(), $dql) === false ? false : true;
     }
-    
+
     /**
      * Sets the position of the first result to retrieve (the "offset").
      *
@@ -484,21 +494,21 @@ final class Query extends AbstractQuery
         $this->_state = self::STATE_DIRTY;
         return $this;
     }
-    
+
     /**
      * Gets the position of the first result the query object was set to retrieve (the "offset").
      * Returns NULL if {@link setFirstResult} was not applied to this query.
-     * 
+     *
      * @return integer The position of the first result.
      */
     public function getFirstResult()
     {
         return $this->_firstResult;
     }
-    
+
     /**
      * Sets the maximum number of results to retrieve (the "limit").
-     * 
+     *
      * @param integer $maxResults
      * @return Query This query object.
      */
@@ -508,11 +518,11 @@ final class Query extends AbstractQuery
         $this->_state = self::STATE_DIRTY;
         return $this;
     }
-    
+
     /**
      * Gets the maximum number of results the query object was set to retrieve (the "limit").
      * Returns NULL if {@link setMaxResults} was not applied to this query.
-     * 
+     *
      * @return integer Maximum number of results.
      */
     public function getMaxResults()
@@ -526,14 +536,14 @@ final class Query extends AbstractQuery
      *
      * @param array $params The query parameters.
      * @param integer $hydrationMode The hydration mode to use.
-     * @return IterableResult
+     * @return \Doctrine\ORM\Internal\Hydration\IterableResult
      */
     public function iterate(array $params = array(), $hydrationMode = self::HYDRATE_OBJECT)
     {
         $this->setHint(self::HINT_INTERNAL_ITERATION, true);
         return parent::iterate($params, $hydrationMode);
     }
-    
+
     /**
      * {@inheritdoc}
      */
@@ -542,7 +552,7 @@ final class Query extends AbstractQuery
         $this->_state = self::STATE_DIRTY;
         return parent::setHint($name, $value);
     }
-    
+
     /**
      * {@inheritdoc}
      */

lib/Doctrine/ORM/Query/Exec/AbstractSqlExecutor.php

@@ -1,7 +1,5 @@
 <?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
@@ -22,6 +20,7 @@
 namespace Doctrine\ORM\Query\Exec;
 
 use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Cache\QueryCacheProfile;
 
 /**
  * Base class for SQL statement executors.
@@ -34,8 +33,16 @@ use Doctrine\DBAL\Connection;
  */
 abstract class AbstractSqlExecutor
 {
+    /**
+     * @var array
+     */
     protected $_sqlStatements;
 
+    /**
+     * @var QueryCacheProfile
+     */
+    protected $queryCacheProfile;
+
     /**
      * Gets the SQL statements that are executed by the executor.
      *
@@ -46,12 +53,18 @@ abstract class AbstractSqlExecutor
         return $this->_sqlStatements;
     }
 
+    public function setQueryCacheProfile(QueryCacheProfile $qcp)
+    {
+        $this->queryCacheProfile = $qcp;
+    }
+
     /**
      * Executes all sql statements.
      *
      * @param Doctrine\DBAL\Connection $conn The database connection that is used to execute the queries.
      * @param array $params  The parameters.
+     * @param array $types The parameter types.
      * @return Doctrine\DBAL\Driver\Statement
      */
-    abstract public function execute(Connection $conn, array $params, array $types);    
+    abstract public function execute(Connection $conn, array $params, array $types);
 }

lib/Doctrine/ORM/Query/Exec/MultiTableDeleteExecutor.php

@@ -1,7 +1,5 @@
 <?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
@@ -32,7 +30,6 @@ use Doctrine\DBAL\Connection,
  * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
  * @link        http://www.doctrine-project.org
  * @since       2.0
- * @version     $Revision$
  */
 class MultiTableDeleteExecutor extends AbstractSqlExecutor
 {
@@ -102,11 +99,7 @@ class MultiTableDeleteExecutor extends AbstractSqlExecutor
     }
 
     /**
-     * Executes all SQL statements.
-     *
-     * @param Doctrine\DBAL\Connection $conn The database connection that is used to execute the queries.
-     * @param array $params The parameters.
-     * @override
+     * {@inheritDoc}
      */
     public function execute(Connection $conn, array $params, array $types)
     {

lib/Doctrine/ORM/Query/Exec/MultiTableUpdateExecutor.php

@@ -141,11 +141,7 @@ class MultiTableUpdateExecutor extends AbstractSqlExecutor
     }
 
     /**
-     * Executes all SQL statements.
-     *
-     * @param Connection $conn The database connection that is used to execute the queries.
-     * @param array $params The parameters.
-     * @override
+     * {@inheritDoc}
      */
     public function execute(Connection $conn, array $params, array $types)
     {

lib/Doctrine/ORM/Query/Exec/SingleSelectExecutor.php

@@ -1,7 +1,5 @@
 <?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
@@ -30,7 +28,6 @@ use Doctrine\DBAL\Connection,
  *
  * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
  * @author      Roman Borschel <roman@code-factory.org>
- * @version     $Revision$
  * @link        www.doctrine-project.org
  * @since       2.0
  */
@@ -41,8 +38,11 @@ class SingleSelectExecutor extends AbstractSqlExecutor
         $this->_sqlStatements = $sqlWalker->walkSelectStatement($AST);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function execute(Connection $conn, array $params, array $types)
     {
-        return $conn->executeQuery($this->_sqlStatements, $params, $types);
+        return $conn->executeQuery($this->_sqlStatements, $params, $types, $this->queryCacheProfile);
     }
 }

lib/Doctrine/ORM/Query/Exec/SingleTableDeleteUpdateExecutor.php

@@ -1,7 +1,5 @@
 <?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
@@ -30,7 +28,6 @@ use Doctrine\DBAL\Connection,
  *
  * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
  * @author      Roman Borschel <roman@code-factory.org>
- * @version     $Revision$
  * @link        www.doctrine-project.org
  * @since       2.0
  * @todo This is exactly the same as SingleSelectExecutor. Unify in SingleStatementExecutor. 
@@ -45,7 +42,10 @@ class SingleTableDeleteUpdateExecutor extends AbstractSqlExecutor
             $this->_sqlStatements = $sqlWalker->walkDeleteStatement($AST);
         }
     }
-    
+
+    /**
+     * {@inheritDoc}
+     */
     public function execute(Connection $conn, array $params, array $types)
     {
         return $conn->executeUpdate($this->_sqlStatements, $params, $types);

lib/Doctrine/ORM/Query/Expr.php

@@ -40,10 +40,12 @@ class Expr
      *
      *     [php]
      *     // (u.type = ?1) AND (u.role = ?2)
-     *     $expr->andX('u.type = ?1', 'u.role = ?2'));
+     *     $expr->andX($expr->eq('u.type', ':1'), $expr->eq('u.role', ':2'));
      *
-     * @param mixed $x Optional clause. Defaults = null, but requires
-     *                 at least one defined when converting to string.
+     * @param Doctrine\ORM\Query\Expr\Comparison | 
+     *          Doctrine\ORM\Query\Expr\Func |
+     *          Doctrine\ORM\Query\Expr\Orx 
+    *               $x Optional clause. Defaults = null, but requires at least one defined when converting to string.
      * @return Expr\Andx
      */
     public function andX($x = null)

lib/Doctrine/ORM/Query/Expr/Base.php

@@ -57,7 +57,7 @@ abstract class Base
 
     public function add($arg)
     {
-        if ( $arg !== null || ($arg instanceof self && $arg->count() > 0)) {
+        if ( $arg !== null || ($arg instanceof self && $arg->count() > 0) ) {
             // If we decide to keep Expr\Base instances, we can use this check
             if ( ! is_string($arg)) {
                 $class = get_class($arg);

lib/Doctrine/ORM/Query/Expr/Composite.php

@@ -39,30 +39,30 @@ class Composite extends Base
         if ($this->count() === 1) {
             return (string) $this->_parts[0];
         }
-        
+
         $components = array();
-        
+
         foreach ($this->_parts as $part) {
             $components[] = $this->processQueryPart($part);
         }
-        
+
         return implode($this->_separator, $components);
     }
-    
-    
+
+
     private function processQueryPart($part)
     {
         $queryPart = (string) $part;
-        
+
         if (is_object($part) && $part instanceof self && $part->count() > 1) {
             return $this->_preSeparator . $queryPart . $this->_postSeparator;
         }
-        
+
         // Fixes DDC-1237: User may have added a where item containing nested expression (with "OR" or "AND")
-        if (mb_stripos($queryPart, ' OR ') !== false || mb_stripos($queryPart, ' AND ') !== false) {
+        if (stripos($queryPart, ' OR ') !== false || stripos($queryPart, ' AND ') !== false) {
             return $this->_preSeparator . $queryPart . $this->_postSeparator;
         }
-        
+
         return $queryPart;
     }
 }

lib/Doctrine/ORM/Query/QueryException.php

@@ -47,6 +47,11 @@ class QueryException extends \Doctrine\ORM\ORMException
         return new self('[Semantical Error] ' . $message);
     }
 
+    public static function invalidLockMode()
+    {
+        return new self('Invalid lock mode hint provided.');
+    }
+
     public static function invalidParameterType($expected, $received)
     {
         return new self('Invalid parameter type, ' . $received . ' given, but ' . $expected . ' expected.');
@@ -72,6 +77,11 @@ class QueryException extends \Doctrine\ORM\ORMException
         return new self("Invalid parameter: token ".$key." is not defined in the query.");
     }
 
+    public static function parameterTypeMissmatch()
+    {
+        return new self("DQL Query parameter and type numbers missmatch, but have to be exactly equal.");
+    }
+
     public static function invalidPathExpression($pathExpr)
     {
         return new self(
@@ -135,7 +145,7 @@ class QueryException extends \Doctrine\ORM\ORMException
             "in the query."
         );
     }
-    
+
     public static function instanceOfUnrelatedClass($className, $rootClass)
     {
         return new self("Cannot check if a child of '" . $rootClass . "' is instanceof '" . $className . "', " .

lib/Doctrine/ORM/Query/ResultSetMapping.php

@@ -26,7 +26,7 @@ namespace Doctrine\ORM\Query;
  * The properties of this class are only public for fast internal READ access and to (drastically)
  * reduce the size of serialized instances for more effective caching due to better (un-)serialization
  * performance.
- * 
+ *
  * <b>Users should use the public methods.</b>
  *
  * @author Roman Borschel <roman@code-factory.org>
@@ -36,87 +36,79 @@ namespace Doctrine\ORM\Query;
 class ResultSetMapping
 {
     /**
-     * Whether the result is mixed (contains scalar values together with field values).
-     * 
      * @ignore
-     * @var boolean
+     * @var boolean Whether the result is mixed (contains scalar values together with field values).
      */
     public $isMixed = false;
+
     /**
-     * Maps alias names to class names.
-     *
      * @ignore
-     * @var array
+     * @var array Maps alias names to class names.
      */
     public $aliasMap = array();
+
     /**
-     * Maps alias names to related association field names.
-     * 
      * @ignore
-     * @var array
+     * @var array Maps alias names to related association field names.
      */
     public $relationMap = array();
+
     /**
-     * Maps alias names to parent alias names.
-     * 
      * @ignore
-     * @var array
+     * @var array Maps alias names to parent alias names.
      */
     public $parentAliasMap = array();
+
     /**
-     * Maps column names in the result set to field names for each class.
-     * 
      * @ignore
-     * @var array
+     * @var array Maps column names in the result set to field names for each class.
      */
     public $fieldMappings = array();
+
     /**
-     * Maps column names in the result set to the alias/field name to use in the mapped result.
-     * 
      * @ignore
-     * @var array
+     * @var array Maps column names in the result set to the alias/field name to use in the mapped result.
      */
     public $scalarMappings = array();
+
     /**
-     * Maps column names of meta columns (foreign keys, discriminator columns, ...) to field names.
-     * 
      * @ignore
-     * @var array
+     * @var array Maps entities in the result set to the alias name to use in the mapped result.
+     */
+    public $entityMappings = array();
+
+    /**
+     * @ignore
+     * @var array Maps column names of meta columns (foreign keys, discriminator columns, ...) to field names.
      */
     public $metaMappings = array();
+
     /**
-     * Maps column names in the result set to the alias they belong to.
-     * 
      * @ignore
-     * @var array
+     * @var array Maps column names in the result set to the alias they belong to.
      */
     public $columnOwnerMap = array();
+
     /**
-     * List of columns in the result set that are used as discriminator columns.
-     * 
      * @ignore
-     * @var array
+     * @var array List of columns in the result set that are used as discriminator columns.
      */
     public $discriminatorColumns = array();
+
     /**
-     * Maps alias names to field names that should be used for indexing.
-     * 
      * @ignore
-     * @var array
+     * @var array Maps alias names to field names that should be used for indexing.
      */
     public $indexByMap = array();
+
     /**
-     * Map from column names to class names that declare the field the column is mapped to.
-     * 
      * @ignore
-     * @var array
+     * @var array Map from column names to class names that declare the field the column is mapped to.
      */
     public $declaringClasses = array();
-    
+
     /**
-     * This is necessary to hydrate derivate foreign keys correctly.
-     * 
-     * @var array
+     * @var array This is necessary to hydrate derivate foreign keys correctly.
      */
     public $isIdentifierColumn = array();
 
@@ -126,11 +118,19 @@ class ResultSetMapping
      * @param string $class The class name of the entity.
      * @param string $alias The alias for the class. The alias must be unique among all entity
      *                      results or joined entity results within this ResultSetMapping.
+     * @param string $resultAlias The result alias with which the entity result should be
+     *                            placed in the result structure.
+     *
      * @todo Rename: addRootEntity
      */
-    public function addEntityResult($class, $alias)
+    public function addEntityResult($class, $alias, $resultAlias = null)
     {
         $this->aliasMap[$alias] = $class;
+        $this->entityMappings[$alias] = $resultAlias;
+
+        if ($resultAlias !== null) {
+            $this->isMixed = true;
+        }
     }
 
     /**
@@ -141,6 +141,7 @@ class ResultSetMapping
      * @param string $alias The alias of the entity result or joined entity result the discriminator
      *                      column should be used for.
      * @param string $discrColumn The name of the discriminator column in the SQL result set.
+     *
      * @todo Rename: addDiscriminatorColumn
      */
     public function setDiscriminatorColumn($alias, $discrColumn)
@@ -157,7 +158,51 @@ class ResultSetMapping
      */
     public function addIndexBy($alias, $fieldName)
     {
-        $this->indexByMap[$alias] = $fieldName;
+        $found = false;
+
+        foreach ($this->fieldMappings AS $columnName => $columnFieldName) {
+            if ( ! ($columnFieldName === $fieldName && $this->columnOwnerMap[$columnName] === $alias)) continue;
+
+            $this->addIndexByColumn($alias, $columnName);
+            $found = true;
+
+            break;
+        }
+
+        /* TODO: check if this exception can be put back, for now it's gone because of assumptions made by some ORM internals
+        if ( ! $found) {
+            $message = sprintf(
+                'Cannot add index by for DQL alias %s and field %s without calling addFieldResult() for them before.',
+                $alias,
+                $fieldName
+            );
+
+            throw new \LogicException($message);
+        }
+        */
+    }
+
+    /**
+     * Set to index by a scalar result column name
+     *
+     * @param $resultColumnName
+     * @return void
+     */
+    public function addIndexByScalar($resultColumnName)
+    {
+        $this->indexByMap['scalars'] = $resultColumnName;
+    }
+
+    /**
+     * Sets a column to use for indexing an entity or joined entity result by the given alias name.
+     *
+     * @param $alias
+     * @param $resultColumnName
+     * @return void
+     */
+    public function addIndexByColumn($alias, $resultColumnName)
+    {
+        $this->indexByMap[$alias] = $resultColumnName;
     }
 
     /**
@@ -207,6 +252,7 @@ class ResultSetMapping
         $this->columnOwnerMap[$columnName] = $alias;
         // field name => class name of declaring class
         $this->declaringClasses[$columnName] = $declaringClass ?: $this->aliasMap[$alias];
+
         if ( ! $this->isMixed && $this->scalarMappings) {
             $this->isMixed = true;
         }
@@ -223,11 +269,11 @@ class ResultSetMapping
      */
     public function addJoinedEntityResult($class, $alias, $parentAlias, $relation)
     {
-        $this->aliasMap[$alias] = $class;
+        $this->aliasMap[$alias]       = $class;
         $this->parentAliasMap[$alias] = $parentAlias;
-        $this->relationMap[$alias] = $relation;
+        $this->relationMap[$alias]    = $relation;
     }
-    
+
     /**
      * Adds a scalar result mapping.
      *
@@ -238,6 +284,7 @@ class ResultSetMapping
     public function addScalarResult($columnName, $alias)
     {
         $this->scalarMappings[$columnName] = $alias;
+
         if ( ! $this->isMixed && $this->fieldMappings) {
             $this->isMixed = true;
         }
@@ -245,7 +292,7 @@ class ResultSetMapping
 
     /**
      * Checks whether a column with a given name is mapped as a scalar result.
-     * 
+     *
      * @param string $columName The name of the column in the SQL result set.
      * @return boolean
      * @todo Rename: isScalar
@@ -384,10 +431,10 @@ class ResultSetMapping
     {
         return $this->isMixed;
     }
-    
+
     /**
      * Adds a meta column (foreign key or discriminator column) to the result set.
-     * 
+     *
      * @param string $alias
      * @param string $columnName
      * @param string $fieldName
@@ -397,8 +444,9 @@ class ResultSetMapping
     {
         $this->metaMappings[$columnName] = $fieldName;
         $this->columnOwnerMap[$columnName] = $alias;
+
         if ($isIdentifierColumn) {
             $this->isIdentifierColumn[$alias][$columnName] = true;
         }
     }
-}
+}

lib/Doctrine/ORM/Query/ResultSetMappingBuilder.php

@@ -86,20 +86,22 @@ class ResultSetMappingBuilder extends ResultSetMapping
             if (isset($renamedColumns[$columnName])) {
                 $columnName = $renamedColumns[$columnName];
             }
+            $columnName = $platform->getSQLResultCasing($columnName);
             if (isset($this->fieldMappings[$columnName])) {
                 throw new \InvalidArgumentException("The column '$columnName' conflicts with another column in the mapper.");
             }
-            $this->addFieldResult($alias, $platform->getSQLResultCasing($columnName), $propertyName);
+            $this->addFieldResult($alias, $columnName, $propertyName);
         }
         foreach ($classMetadata->associationMappings AS $associationMapping) {
             if ($associationMapping['isOwningSide'] && $associationMapping['type'] & ClassMetadataInfo::TO_ONE) {
                 foreach ($associationMapping['joinColumns'] AS $joinColumn) {
                     $columnName = $joinColumn['name'];
                     $renamedColumnName = isset($renamedColumns[$columnName]) ? $renamedColumns[$columnName] : $columnName;
+                    $renamedColumnName = $platform->getSQLResultCasing($renamedColumnName);
                     if (isset($this->metaMappings[$renamedColumnName])) {
                         throw new \InvalidArgumentException("The column '$renamedColumnName' conflicts with another column in the mapper.");
                     }
-                    $this->addMetaResult($alias, $platform->getSQLResultCasing($renamedColumnName), $platform->getSQLResultCasing($columnName));
+                    $this->addMetaResult($alias, $renamedColumnName, $columnName);
                 }
             }
         }

lib/Doctrine/ORM/QueryBuilder.php

@@ -74,7 +74,7 @@ class QueryBuilder
      * @var string The complete DQL string for this query.
      */
     private $_dql;
-    
+
     /**
      * @var array The query parameters.
      */
@@ -84,12 +84,12 @@ class QueryBuilder
      * @var array The parameter type map of this query.
      */
     private $_paramTypes = array();
-    
+
     /**
      * @var integer The index of the first result to retrieve.
      */
     private $_firstResult = null;
-    
+
     /**
      * @var integer The maximum number of results to retrieve.
      */
@@ -97,7 +97,7 @@ class QueryBuilder
 
     /**
      * Initializes a new <tt>QueryBuilder</tt> that uses the given <tt>EntityManager</tt>.
-     * 
+     *
      * @param EntityManager $em The EntityManager to use.
      */
     public function __construct(EntityManager $em)
@@ -217,7 +217,7 @@ class QueryBuilder
                 ->setFirstResult($this->_firstResult)
                 ->setMaxResults($this->_maxResults);
     }
-    
+
     /**
      * Gets the FIRST root alias of the query. This is the first entity alias involved
      * in the construction of the query.
@@ -256,7 +256,7 @@ class QueryBuilder
     public function getRootAliases()
     {
         $aliases = array();
-        
+
         foreach ($this->_dqlParts['from'] as &$fromClause) {
             if (is_string($fromClause)) {
                 $spacePos = strrpos($fromClause, ' ');
@@ -265,10 +265,10 @@ class QueryBuilder
 
                 $fromClause = new Query\Expr\From($from, $alias);
             }
-            
+
             $aliases[] = $fromClause->getAlias();
         }
-        
+
         return $aliases;
     }
 
@@ -289,7 +289,7 @@ class QueryBuilder
     public function getRootEntities()
     {
         $entities = array();
-        
+
         foreach ($this->_dqlParts['from'] as &$fromClause) {
             if (is_string($fromClause)) {
                 $spacePos = strrpos($fromClause, ' ');
@@ -298,10 +298,10 @@ class QueryBuilder
 
                 $fromClause = new Query\Expr\From($from, $alias);
             }
-            
+
             $entities[] = $fromClause->getFrom();
         }
-        
+
         return $entities;
     }
 
@@ -313,7 +313,7 @@ class QueryBuilder
      *         ->select('u')
      *         ->from('User', 'u')
      *         ->where('u.id = :user_id')
-     *         ->setParameter(':user_id', 1);
+     *         ->setParameter('user_id', 1);
      * </code>
      *
      * @param string|integer $key The parameter position or name.
@@ -324,17 +324,17 @@ class QueryBuilder
     public function setParameter($key, $value, $type = null)
     {
         $key = trim($key, ':');
-        
+
         if ($type === null) {
             $type = Query\ParameterTypeInferer::inferType($value);
         }
-        
+
         $this->_paramTypes[$key] = $type;
         $this->_params[$key] = $value;
-        
+
         return $this;
     }
-    
+
     /**
      * Sets a collection of query parameters for the query being constructed.
      *
@@ -344,8 +344,8 @@ class QueryBuilder
      *         ->from('User', 'u')
      *         ->where('u.id = :user_id1 OR u.id = :user_id2')
      *         ->setParameters(array(
-     *             ':user_id1' => 1,
-     *             ':user_id2' => 2
+     *             'user_id1' => 1,
+     *             'user_id2' => 2
      *         ));
      * </code>
      *
@@ -376,7 +376,7 @@ class QueryBuilder
 
     /**
      * Gets a (previously set) query parameter of the query being constructed.
-     * 
+     *
      * @param mixed $key The key (index or name) of the bound parameter.
      * @return mixed The value of the bound parameter.
      */
@@ -400,17 +400,17 @@ class QueryBuilder
     /**
      * Gets the position of the first result the query object was set to retrieve (the "offset").
      * Returns NULL if {@link setFirstResult} was not applied to this QueryBuilder.
-     * 
+     *
      * @return integer The position of the first result.
      */
     public function getFirstResult()
     {
         return $this->_firstResult;
     }
-    
+
     /**
      * Sets the maximum number of results to retrieve (the "limit").
-     * 
+     *
      * @param integer $maxResults The maximum number of results to retrieve.
      * @return QueryBuilder This QueryBuilder instance.
      */
@@ -419,11 +419,11 @@ class QueryBuilder
         $this->_maxResults = $maxResults;
         return $this;
     }
-    
+
     /**
      * Gets the maximum number of results the query object was set to retrieve (the "limit").
      * Returns NULL if {@link setMaxResults} was not applied to this query builder.
-     * 
+     *
      * @return integer Maximum number of results.
      */
     public function getMaxResults()
@@ -437,15 +437,15 @@ class QueryBuilder
      * The available parts are: 'select', 'from', 'join', 'set', 'where',
      * 'groupBy', 'having' and 'orderBy'.
      *
-     * @param string $dqlPartName 
-     * @param string $dqlPart 
-     * @param string $append 
+     * @param string $dqlPartName
+     * @param string $dqlPart
+     * @param string $append
      * @return QueryBuilder This QueryBuilder instance.
      */
     public function add($dqlPartName, $dqlPart, $append = false)
     {
         $isMultiple = is_array($this->_dqlParts[$dqlPartName]);
-        
+
         // This is introduced for backwards compatibility reasons.
         // TODO: Remove for 3.0
         if ($dqlPartName == 'join') {
@@ -459,11 +459,11 @@ class QueryBuilder
             }
             $dqlPart = $newDqlPart;
         }
-    
+
         if ($append && $isMultiple) {
             if (is_array($dqlPart)) {
                 $key = key($dqlPart);
-                
+
                 $this->_dqlParts[$dqlPartName][$key][] = $dqlPart[$key];
             } else {
                 $this->_dqlParts[$dqlPartName][] = $dqlPart;
@@ -494,11 +494,11 @@ class QueryBuilder
     public function select($select = null)
     {
         $this->_type = self::SELECT;
-        
+
         if (empty($select)) {
             return $this;
         }
-        
+
         $selects = is_array($select) ? $select : func_get_args();
 
         return $this->add('select', new Expr\Select($selects), false);
@@ -521,11 +521,11 @@ class QueryBuilder
     public function addSelect($select = null)
     {
         $this->_type = self::SELECT;
-        
+
         if (empty($select)) {
             return $this;
         }
-        
+
         $selects = is_array($select) ? $select : func_get_args();
 
         return $this->add('select', new Expr\Select($selects), true);
@@ -539,7 +539,7 @@ class QueryBuilder
      *     $qb = $em->createQueryBuilder()
      *         ->delete('User', 'u')
      *         ->where('u.id = :user_id');
-     *         ->setParameter(':user_id', 1);
+     *         ->setParameter('user_id', 1);
      * </code>
      *
      * @param string $delete The class/type whose instances are subject to the deletion.
@@ -631,7 +631,7 @@ class QueryBuilder
 
     /**
      * Creates and adds a join over an entity association to the query.
-     * 
+     *
      * The entities in the joined association will be fetched as part of the query
      * result if the alias used for the joined association is placed in the select
      * expressions.
@@ -655,7 +655,7 @@ class QueryBuilder
         if (!in_array($rootAlias, $this->getRootAliases())) {
             $rootAlias = $this->getRootAlias();
         }
-        
+
         return $this->add('join', array(
             $rootAlias => new Expr\Join(Expr\Join::INNER_JOIN, $join, $alias, $conditionType, $condition, $indexBy)
         ), true);
@@ -688,7 +688,7 @@ class QueryBuilder
         if (!in_array($rootAlias, $this->getRootAliases())) {
             $rootAlias = $this->getRootAlias();
         }
-        
+
         return $this->add('join', array(
             $rootAlias => new Expr\Join(Expr\Join::LEFT_JOIN, $join, $alias, $conditionType, $condition, $indexBy)
         ), true);
@@ -743,7 +743,7 @@ class QueryBuilder
         if ( ! (func_num_args() == 1 && $predicates instanceof Expr\Composite)) {
             $predicates = new Expr\Andx(func_get_args());
         }
-        
+
         return $this->add('where', $predicates);
     }
 
@@ -767,14 +767,14 @@ class QueryBuilder
     {
         $where = $this->getDQLPart('where');
         $args = func_get_args();
-        
+
         if ($where instanceof Expr\Andx) {
             $where->addMultiple($args);
-        } else { 
+        } else {
             array_unshift($args, $where);
             $where = new Expr\Andx($args);
         }
-        
+
         return $this->add('where', $where, true);
     }
 
@@ -798,14 +798,14 @@ class QueryBuilder
     {
         $where = $this->getDqlPart('where');
         $args = func_get_args();
-        
+
         if ($where instanceof Expr\Orx) {
             $where->addMultiple($args);
-        } else {            
+        } else {
             array_unshift($args, $where);
             $where = new Expr\Orx($args);
         }
-        
+
         return $this->add('where', $where, true);
     }
 
@@ -860,7 +860,7 @@ class QueryBuilder
         if ( ! (func_num_args() == 1 && ($having instanceof Expr\Andx || $having instanceof Expr\Orx))) {
             $having = new Expr\Andx(func_get_args());
         }
-        
+
         return $this->add('having', $having);
     }
 
@@ -875,14 +875,14 @@ class QueryBuilder
     {
         $having = $this->getDqlPart('having');
         $args = func_get_args();
-        
+
         if ($having instanceof Expr\Andx) {
             $having->addMultiple($args);
-        } else { 
+        } else {
             array_unshift($args, $having);
             $having = new Expr\Andx($args);
         }
-        
+
         return $this->add('having', $having);
     }
 
@@ -897,10 +897,10 @@ class QueryBuilder
     {
         $having = $this->getDqlPart('having');
         $args = func_get_args();
-        
+
         if ($having instanceof Expr\Orx) {
             $having->addMultiple($args);
-        } else { 
+        } else {
             array_unshift($args, $having);
             $having = new Expr\Orx($args);
         }
@@ -977,15 +977,15 @@ class QueryBuilder
     private function _getDQLForSelect()
     {
         $dql = 'SELECT' . $this->_getReducedDQLQueryPart('select', array('pre' => ' ', 'separator' => ', '));
-        
+
         $fromParts   = $this->getDQLPart('from');
         $joinParts   = $this->getDQLPart('join');
         $fromClauses = array();
-        
+
         // Loop through all FROM clauses
         if ( ! empty($fromParts)) {
             $dql .= ' FROM ';
-            
+
             foreach ($fromParts as $from) {
                 $fromClause = (string) $from;
 
@@ -998,24 +998,24 @@ class QueryBuilder
                 $fromClauses[] = $fromClause;
             }
         }
-        
-        $dql .= implode(', ', $fromClauses) 
+
+        $dql .= implode(', ', $fromClauses)
               . $this->_getReducedDQLQueryPart('where', array('pre' => ' WHERE '))
               . $this->_getReducedDQLQueryPart('groupBy', array('pre' => ' GROUP BY ', 'separator' => ', '))
               . $this->_getReducedDQLQueryPart('having', array('pre' => ' HAVING '))
               . $this->_getReducedDQLQueryPart('orderBy', array('pre' => ' ORDER BY ', 'separator' => ', '));
-        
+
         return $dql;
     }
 
     private function _getReducedDQLQueryPart($queryPartName, $options = array())
     {
         $queryPart = $this->getDQLPart($queryPartName);
-        
+
         if (empty($queryPart)) {
             return (isset($options['empty']) ? $options['empty'] : '');
         }
-        
+
         return (isset($options['pre']) ? $options['pre'] : '')
              . (is_array($queryPart) ? implode($options['separator'], $queryPart) : $queryPart)
              . (isset($options['post']) ? $options['post'] : '');

lib/Doctrine/ORM/Tools/EntityGenerator.php

@@ -117,7 +117,7 @@ public function <methodName>()
  * @param <variableType>$<variableName>
  * @return <entity>
  */
-public function <methodName>(<methodTypeHint>$<variableName>)
+public function <methodName>(<methodTypeHint>$<variableName><variableDefault>)
 {
 <spaces>$this-><fieldName> = $<variableName>;
 <spaces>return $this;
@@ -406,7 +406,7 @@ public function <methodName>()
         }
         
         if ($collections) {
-            return $this->_prefixCodeWithSpaces(str_replace("<collections>", implode("\n", $collections), self::$_constructorMethodTemplate));
+            return $this->_prefixCodeWithSpaces(str_replace("<collections>", implode("\n".$this->_spaces, $collections), self::$_constructorMethodTemplate));
         }
         
         return '';
@@ -634,7 +634,8 @@ public function <methodName>()
 
         foreach ($metadata->associationMappings as $associationMapping) {
             if ($associationMapping['type'] & ClassMetadataInfo::TO_ONE) {
-                if ($code = $this->_generateEntityStubMethod($metadata, 'set', $associationMapping['fieldName'], $associationMapping['targetEntity'])) {
+                $nullable = $this->_isAssociationIsNullable($associationMapping) ? 'null' : null;
+                if ($code = $this->_generateEntityStubMethod($metadata, 'set', $associationMapping['fieldName'], $associationMapping['targetEntity'], $nullable)) {
                     $methods[] = $code;
                 }
                 if ($code = $this->_generateEntityStubMethod($metadata, 'get', $associationMapping['fieldName'], $associationMapping['targetEntity'])) {
@@ -653,6 +654,22 @@ public function <methodName>()
         return implode("\n\n", $methods);
     }
 
+    private function _isAssociationIsNullable($associationMapping)
+    {
+        if (isset($associationMapping['joinColumns'])) {
+            $joinColumns = $associationMapping['joinColumns'];
+        } else {
+            //@todo thereis no way to retreive targetEntity metadata
+            $joinColumns = array();
+        }
+        foreach ($joinColumns as $joinColumn) {
+            if(isset($joinColumn['nullable']) && !$joinColumn['nullable']) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     private function _generateEntityLifecycleCallbackMethods(ClassMetadataInfo $metadata)
     {
         if (isset($metadata->lifecycleCallbacks) && $metadata->lifecycleCallbacks) {
@@ -707,7 +724,7 @@ public function <methodName>()
         return implode("\n", $lines);
     }
 
-    private function _generateEntityStubMethod(ClassMetadataInfo $metadata, $type, $fieldName, $typeHint = null)
+    private function _generateEntityStubMethod(ClassMetadataInfo $metadata, $type, $fieldName, $typeHint = null,  $defaultValue = null)
     {
         if ($type == "add") {
             $addMethod = explode("\\", $typeHint);
@@ -737,6 +754,7 @@ public function <methodName>()
           '<variableName>'      => Inflector::camelize($fieldName),
           '<methodName>'        => $methodName,
           '<fieldName>'         => $fieldName,
+          '<variableDefault>'   => ($defaultValue !== null ) ? ('='.$defaultValue) : '',
           '<entity>'            => $this->_getClassName($metadata)
         );
 
@@ -805,7 +823,12 @@ public function <methodName>()
     {
         $lines = array();
         $lines[] = $this->_spaces . '/**';
-        $lines[] = $this->_spaces . ' * @var ' . $associationMapping['targetEntity'];
+
+        if ($associationMapping['type'] & ClassMetadataInfo::TO_MANY) {
+            $lines[] = $this->_spaces . ' * @var \Doctrine\Common\Collections\ArrayCollection';
+        } else {
+            $lines[] = $this->_spaces . ' * @var ' . $associationMapping['targetEntity'];
+        }
 
         if ($this->_generateAnnotations) {
             $lines[] = $this->_spaces . ' *';

lib/Doctrine/ORM/Tools/Export/Driver/XmlExporter.php

@@ -279,6 +279,9 @@ class XmlExporter extends AbstractExporter
             if ($associationMapping['isCascadeDetach']) {
                 $cascade[] = 'cascade-detach';
             }
+            if (count($cascade) === 5) {
+                $cascade  = array('cascade-all');
+            }
             if ($cascade) {
                 $cascadeXml = $associationMappingXml->addChild('cascade');
                 foreach ($cascade as $type) {

lib/Doctrine/ORM/Tools/Export/Driver/YamlExporter.php

@@ -147,6 +147,9 @@ class YamlExporter extends AbstractExporter
             if ($associationMapping['isCascadeDetach']) {
                 $cascade[] = 'detach';
             }
+            if (count($cascade) === 5) {
+                $cascade = array('all');
+            }
             $associationMappingArray = array(
                 'targetEntity' => $associationMapping['targetEntity'],
                 'cascade'     => $cascade,

lib/Doctrine/ORM/Tools/SchemaTool.php

@@ -67,7 +67,9 @@ class SchemaTool
     /**
      * Creates the database schema for the given array of ClassMetadata instances.
      *
+     * @throws ToolsException
      * @param array $classes
+     * @return void
      */
     public function createSchema(array $classes)
     {
@@ -75,7 +77,11 @@ class SchemaTool
         $conn = $this->_em->getConnection();
 
         foreach ($createSchemaSql as $sql) {
-            $conn->executeQuery($sql);
+            try {
+                $conn->executeQuery($sql);
+            } catch(\Exception $e) {
+                throw ToolsException::schemaToolFailure($sql, $e);
+            }
         }
     }
 
@@ -94,7 +100,7 @@ class SchemaTool
 
     /**
      * Some instances of ClassMetadata don't need to be processed in the SchemaTool context. This method detects them.
-     * 
+     *
      * @param ClassMetadata $class
      * @param array $processedClasses
      * @return bool
@@ -139,7 +145,7 @@ class SchemaTool
                 $this->_gatherRelationsSql($class, $table, $schema);
 
                 // Add the discriminator column
-                $discrColumnDef = $this->_getDiscriminatorColumnDefinition($class, $table);
+                $this->addDiscriminatorColumnDefinition($class, $table);
 
                 // Aggregate all the information from all classes in the hierarchy
                 foreach ($class->parentClasses as $parentClassName) {
@@ -171,7 +177,7 @@ class SchemaTool
 
                 // Add the discriminator column only to the root table
                 if ($class->name == $class->rootEntityName) {
-                    $discrColumnDef = $this->_getDiscriminatorColumnDefinition($class, $table);
+                    $this->addDiscriminatorColumnDefinition($class, $table);
                 } else {
                     // Add an ID FK column to child tables
                     /* @var Doctrine\ORM\Mapping\ClassMetadata $class */
@@ -261,7 +267,7 @@ class SchemaTool
      * @return array The portable column definition of the discriminator column as required by
      *              the DBAL.
      */
-    private function _getDiscriminatorColumnDefinition($class, $table)
+    private function addDiscriminatorColumnDefinition($class, $table)
     {
         $discrColumn = $class->discriminatorColumn;
 
@@ -551,7 +557,7 @@ class SchemaTool
             try {
                 $conn->executeQuery($sql);
             } catch(\Exception $e) {
-                
+
             }
         }
     }
@@ -589,7 +595,7 @@ class SchemaTool
 
     /**
      * Get SQL to drop the tables defined by the passed classes.
-     * 
+     *
      * @param array $classes
      * @return array
      */
@@ -615,7 +621,7 @@ class SchemaTool
                 }
             }
         }
-        
+
         if ($this->_platform->supportsSequences()) {
             foreach ($schema->getSequences() AS $sequence) {
                 $visitor->acceptSequence($sequence);
@@ -659,7 +665,7 @@ class SchemaTool
     /**
      * Gets the sequence of SQL statements that need to be performed in order
      * to bring the given class mappings in-synch with the relational schema.
-     * If $saveMode is set to true the command is executed in the Database, 
+     * If $saveMode is set to true the command is executed in the Database,
      * else SQL is returned.
      *
      * @param array $classes The classes to consider.

lib/Doctrine/ORM/Tools/SchemaValidator.php

@@ -50,7 +50,7 @@ class SchemaValidator
     }
 
     /**
-     * Checks the internal consistency of mapping files.
+     * Checks the internal consistency of all mapping files.
      *
      * There are several checks that can't be done at runtime or are too expensive, which can be verified
      * with this command. For example:
@@ -69,150 +69,7 @@ class SchemaValidator
         $classes = $cmf->getAllMetadata();
 
         foreach ($classes AS $class) {
-            $ce = array();
-            /* @var $class ClassMetadata */
-            foreach ($class->associationMappings AS $fieldName => $assoc) {
-                if (!$cmf->hasMetadataFor($assoc['targetEntity'])) {
-                    $ce[] = "The target entity '" . $assoc['targetEntity'] . "' specified on " . $class->name . '#' . $fieldName . ' is unknown.';
-                }
-
-                if ($assoc['mappedBy'] && $assoc['inversedBy']) {
-                    $ce[] = "The association " . $class . "#" . $fieldName . " cannot be defined as both inverse and owning.";
-                }
-
-                $targetMetadata = $cmf->getMetadataFor($assoc['targetEntity']);
-
-                /* @var $assoc AssociationMapping */
-                if ($assoc['mappedBy']) {
-                    if ($targetMetadata->hasField($assoc['mappedBy'])) {
-                        $ce[] = "The association " . $class->name . "#" . $fieldName . " refers to the owning side ".
-                                "field " . $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " which is not defined as association.";
-                    }
-                    if (!$targetMetadata->hasAssociation($assoc['mappedBy'])) {
-                        $ce[] = "The association " . $class->name . "#" . $fieldName . " refers to the owning side ".
-                                "field " . $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " which does not exist.";
-                    } else if ($targetMetadata->associationMappings[$assoc['mappedBy']]['inversedBy'] == null) {
-                        $ce[] = "The field " . $class->name . "#" . $fieldName . " is on the inverse side of a ".
-                                "bi-directional relationship, but the specified mappedBy association on the target-entity ".
-                                $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " does not contain the required ".
-                                "'inversedBy' attribute.";
-                    } else  if ($targetMetadata->associationMappings[$assoc['mappedBy']]['inversedBy'] != $fieldName) {
-                        $ce[] = "The mappings " . $class->name . "#" . $fieldName . " and " .
-                                $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " are ".
-                                "incosistent with each other.";
-                    }
-                }
-
-                if ($assoc['inversedBy']) {
-                    if ($targetMetadata->hasField($assoc['inversedBy'])) {
-                        $ce[] = "The association " . $class->name . "#" . $fieldName . " refers to the inverse side ".
-                                "field " . $assoc['targetEntity'] . "#" . $assoc['inversedBy'] . " which is not defined as association.";
-                    }
-                    if (!$targetMetadata->hasAssociation($assoc['inversedBy'])) {
-                        $ce[] = "The association " . $class->name . "#" . $fieldName . " refers to the inverse side ".
-                                "field " . $assoc['targetEntity'] . "#" . $assoc['inversedBy'] . " which does not exist.";
-                    } else if ($targetMetadata->associationMappings[$assoc['inversedBy']]['mappedBy'] == null) {
-                        $ce[] = "The field " . $class->name . "#" . $fieldName . " is on the owning side of a ".
-                                "bi-directional relationship, but the specified mappedBy association on the target-entity ".
-                                $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " does not contain the required ".
-                                "'inversedBy' attribute.";
-                    } else  if ($targetMetadata->associationMappings[$assoc['inversedBy']]['mappedBy'] != $fieldName) {
-                        $ce[] = "The mappings " . $class->name . "#" . $fieldName . " and " .
-                                $assoc['targetEntity'] . "#" . $assoc['inversedBy'] . " are ".
-                                "incosistent with each other.";
-                    }
-                }
-
-                if ($assoc['isOwningSide']) {
-                    if ($assoc['type'] == ClassMetadataInfo::MANY_TO_MANY) {
-                        foreach ($assoc['joinTable']['joinColumns'] AS $joinColumn) {
-                            if (!isset($class->fieldNames[$joinColumn['referencedColumnName']])) {
-                                $ce[] = "The referenced column name '" . $joinColumn['referencedColumnName'] . "' does not " .
-                                        "have a corresponding field with this column name on the class '" . $class->name . "'.";
-                                break;
-                            }
-
-                            $fieldName = $class->fieldNames[$joinColumn['referencedColumnName']];
-                            if (!in_array($fieldName, $class->identifier)) {
-                                $ce[] = "The referenced column name '" . $joinColumn['referencedColumnName'] . "' " .
-                                        "has to be a primary key column.";
-                            }
-                        }
-                        foreach ($assoc['joinTable']['inverseJoinColumns'] AS $inverseJoinColumn) {
-                            $targetClass = $cmf->getMetadataFor($assoc['targetEntity']);
-                            if (!isset($targetClass->fieldNames[$inverseJoinColumn['referencedColumnName']])) {
-                                $ce[] = "The inverse referenced column name '" . $inverseJoinColumn['referencedColumnName'] . "' does not " .
-                                        "have a corresponding field with this column name on the class '" . $targetClass->name . "'.";
-                                break;
-                            }
-
-                            $fieldName = $targetClass->fieldNames[$inverseJoinColumn['referencedColumnName']];
-                            if (!in_array($fieldName, $targetClass->identifier)) {
-                                $ce[] = "The referenced column name '" . $inverseJoinColumn['referencedColumnName'] . "' " .
-                                        "has to be a primary key column.";
-                            }
-                        }
-
-                        if (count($targetClass->identifier) != count($assoc['joinTable']['inverseJoinColumns'])) {
-                            $ce[] = "The inverse join columns of the many-to-many table '" . $assoc['joinTable']['name'] . "' " .
-                                    "have to match to ALL identifier columns of the target entity '". $targetClass->name . "'";
-                        }
-
-                        if (count($class->identifier) != count($assoc['joinTable']['joinColumns'])) {
-                            $ce[] = "The join columns of the many-to-many table '" . $assoc['joinTable']['name'] . "' " .
-                                    "have to match to ALL identifier columns of the source entity '". $class->name . "'";
-                        }
-
-                    } else if ($assoc['type'] & ClassMetadataInfo::TO_ONE) {
-                        foreach ($assoc['joinColumns'] AS $joinColumn) {
-                            $targetClass = $cmf->getMetadataFor($assoc['targetEntity']);
-                            if (!isset($targetClass->fieldNames[$joinColumn['referencedColumnName']])) {
-                                $ce[] = "The referenced column name '" . $joinColumn['referencedColumnName'] . "' does not " .
-                                        "have a corresponding field with this column name on the class '" . $targetClass->name . "'.";
-                                break;
-                            }
-
-                            $fieldName = $targetClass->fieldNames[$joinColumn['referencedColumnName']];
-                            if (!in_array($fieldName, $targetClass->identifier)) {
-                                $ce[] = "The referenced column name '" . $joinColumn['referencedColumnName'] . "' " .
-                                        "has to be a primary key column.";
-                            }
-                        }
-
-                        if (count($class->identifier) != count($assoc['joinColumns'])) {
-                            $ce[] = "The join columns of the association '" . $assoc['fieldName'] . "' " .
-                                    "have to match to ALL identifier columns of the source entity '". $class->name . "'";
-                        }
-                    }
-                }
-
-                if (isset($assoc['orderBy']) && $assoc['orderBy'] !== null) {
-                    $targetClass = $cmf->getMetadataFor($assoc['targetEntity']);
-                    foreach ($assoc['orderBy'] AS $orderField => $orientation) {
-                        if (!$targetClass->hasField($orderField)) {
-                            $ce[] = "The association " . $class->name."#".$fieldName." is ordered by a foreign field " .
-                                    $orderField . " that is not a field on the target entity " . $targetClass->name;
-                        }
-                    }
-                }
-            }
-
-            foreach ($class->reflClass->getProperties(\ReflectionProperty::IS_PUBLIC) as $publicAttr) {
-                if ($publicAttr->isStatic()) {
-                    continue;
-                }
-                $ce[] = "Field '".$publicAttr->getName()."' in class '".$class->name."' must be private ".
-                        "or protected. Public fields may break lazy-loading.";
-            }
-
-            foreach ($class->subClasses AS $subClass) {
-                if (!in_array($class->name, class_parents($subClass))) {
-                    $ce[] = "According to the discriminator map class '" . $subClass . "' has to be a child ".
-                            "of '" . $class->name . "' but these entities are not related through inheritance.";
-                }
-            }
-
-            if ($ce) {
+            if ($ce = $this->validateClass($class)) {
                 $errors[$class->name] = $ce;
             }
         }
@@ -220,6 +77,170 @@ class SchemaValidator
         return $errors;
     }
 
+    /**
+     * Validate a single class of the current
+     *
+     * @param ClassMetadataInfo $class
+     * @return array
+     */
+    public function validateClass(ClassMetadataInfo $class)
+    {
+        $ce = array();
+        $cmf = $this->em->getMetadataFactory();
+
+        foreach ($class->associationMappings AS $fieldName => $assoc) {
+            if (!$cmf->hasMetadataFor($assoc['targetEntity'])) {
+                $ce[] = "The target entity '" . $assoc['targetEntity'] . "' specified on " . $class->name . '#' . $fieldName . ' is unknown.';
+                return $ce;
+            }
+
+            if ($assoc['mappedBy'] && $assoc['inversedBy']) {
+                $ce[] = "The association " . $class . "#" . $fieldName . " cannot be defined as both inverse and owning.";
+            }
+
+            $targetMetadata = $cmf->getMetadataFor($assoc['targetEntity']);
+
+            /* @var $assoc AssociationMapping */
+            if ($assoc['mappedBy']) {
+                if ($targetMetadata->hasField($assoc['mappedBy'])) {
+                    $ce[] = "The association " . $class->name . "#" . $fieldName . " refers to the owning side ".
+                            "field " . $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " which is not defined as association.";
+                }
+                if (!$targetMetadata->hasAssociation($assoc['mappedBy'])) {
+                    $ce[] = "The association " . $class->name . "#" . $fieldName . " refers to the owning side ".
+                            "field " . $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " which does not exist.";
+                } else if ($targetMetadata->associationMappings[$assoc['mappedBy']]['inversedBy'] == null) {
+                    $ce[] = "The field " . $class->name . "#" . $fieldName . " is on the inverse side of a ".
+                            "bi-directional relationship, but the specified mappedBy association on the target-entity ".
+                            $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " does not contain the required ".
+                            "'inversedBy' attribute.";
+                } else  if ($targetMetadata->associationMappings[$assoc['mappedBy']]['inversedBy'] != $fieldName) {
+                    $ce[] = "The mappings " . $class->name . "#" . $fieldName . " and " .
+                            $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " are ".
+                            "incosistent with each other.";
+                }
+            }
+
+            if ($assoc['inversedBy']) {
+                if ($targetMetadata->hasField($assoc['inversedBy'])) {
+                    $ce[] = "The association " . $class->name . "#" . $fieldName . " refers to the inverse side ".
+                            "field " . $assoc['targetEntity'] . "#" . $assoc['inversedBy'] . " which is not defined as association.";
+                }
+                if (!$targetMetadata->hasAssociation($assoc['inversedBy'])) {
+                    $ce[] = "The association " . $class->name . "#" . $fieldName . " refers to the inverse side ".
+                            "field " . $assoc['targetEntity'] . "#" . $assoc['inversedBy'] . " which does not exist.";
+                } else if ($targetMetadata->associationMappings[$assoc['inversedBy']]['mappedBy'] == null) {
+                    $ce[] = "The field " . $class->name . "#" . $fieldName . " is on the owning side of a ".
+                            "bi-directional relationship, but the specified mappedBy association on the target-entity ".
+                            $assoc['targetEntity'] . "#" . $assoc['mappedBy'] . " does not contain the required ".
+                            "'inversedBy' attribute.";
+                } else  if ($targetMetadata->associationMappings[$assoc['inversedBy']]['mappedBy'] != $fieldName) {
+                    $ce[] = "The mappings " . $class->name . "#" . $fieldName . " and " .
+                            $assoc['targetEntity'] . "#" . $assoc['inversedBy'] . " are ".
+                            "incosistent with each other.";
+                }
+            }
+
+            if ($assoc['isOwningSide']) {
+                if ($assoc['type'] == ClassMetadataInfo::MANY_TO_MANY) {
+                    foreach ($assoc['joinTable']['joinColumns'] AS $joinColumn) {
+                        if (!isset($class->fieldNames[$joinColumn['referencedColumnName']])) {
+                            $ce[] = "The referenced column name '" . $joinColumn['referencedColumnName'] . "' does not " .
+                                    "have a corresponding field with this column name on the class '" . $class->name . "'.";
+                            break;
+                        }
+
+                        $fieldName = $class->fieldNames[$joinColumn['referencedColumnName']];
+                        if (!in_array($fieldName, $class->identifier)) {
+                            $ce[] = "The referenced column name '" . $joinColumn['referencedColumnName'] . "' " .
+                                    "has to be a primary key column.";
+                        }
+                    }
+                    foreach ($assoc['joinTable']['inverseJoinColumns'] AS $inverseJoinColumn) {
+                        if (!isset($targetMetadata->fieldNames[$inverseJoinColumn['referencedColumnName']])) {
+                            $ce[] = "The inverse referenced column name '" . $inverseJoinColumn['referencedColumnName'] . "' does not " .
+                                    "have a corresponding field with this column name on the class '" . $targetMetadata->name . "'.";
+                            break;
+                        }
+
+                        $fieldName = $targetMetadata->fieldNames[$inverseJoinColumn['referencedColumnName']];
+                        if (!in_array($fieldName, $targetMetadata->identifier)) {
+                            $ce[] = "The referenced column name '" . $inverseJoinColumn['referencedColumnName'] . "' " .
+                                    "has to be a primary key column.";
+                        }
+                    }
+
+                    if (count($targetMetadata->getIdentifierColumnNames()) != count($assoc['joinTable']['inverseJoinColumns'])) {
+                        $ce[] = "The inverse join columns of the many-to-many table '" . $assoc['joinTable']['name'] . "' " .
+                                "have to contain to ALL identifier columns of the target entity '". $targetMetadata->name . "', " .
+                                "however '" . implode(", ", array_diff($targetMetadata->getIdentifierColumnNames(), array_values($assoc['relationToTargetKeyColumns']))) .
+                                "' are missing.";
+                    }
+
+                    if (count($class->getIdentifierColumnNames()) != count($assoc['joinTable']['joinColumns'])) {
+                        $ce[] = "The join columns of the many-to-many table '" . $assoc['joinTable']['name'] . "' " .
+                                "have to contain to ALL identifier columns of the source entity '". $class->name . "', " .
+                                "however '" . implode(", ", array_diff($class->getIdentifierColumnNames(), array_values($assoc['relationToSourceKeyColumns']))) .
+                                "' are missing.";
+                    }
+
+                } else if ($assoc['type'] & ClassMetadataInfo::TO_ONE) {
+                    foreach ($assoc['joinColumns'] AS $joinColumn) {
+                        if (!isset($targetMetadata->fieldNames[$joinColumn['referencedColumnName']])) {
+                            $ce[] = "The referenced column name '" . $joinColumn['referencedColumnName'] . "' does not " .
+                                    "have a corresponding field with this column name on the class '" . $targetMetadata->name . "'.";
+                            break;
+                        }
+
+                        $fieldName = $targetMetadata->fieldNames[$joinColumn['referencedColumnName']];
+                        if (!in_array($fieldName, $targetMetadata->identifier)) {
+                            $ce[] = "The referenced column name '" . $joinColumn['referencedColumnName'] . "' " .
+                                    "has to be a primary key column.";
+                        }
+                    }
+
+                    if (count($class->getIdentifierColumnNames()) != count($assoc['joinColumns'])) {
+                        $ids = array();
+                        foreach ($assoc['joinColumns'] AS $joinColumn) {
+                            $ids[] = $joinColumn['name'];
+                        }
+
+                        $ce[] = "The join columns of the association '" . $assoc['fieldName'] . "' " .
+                                "have to match to ALL identifier columns of the source entity '". $class->name . "', " .
+                                "however '" . implode(", ", array_diff($class->getIdentifierColumnNames(), $ids)) .
+                                "' are missing.";
+                    }
+                }
+            }
+
+            if (isset($assoc['orderBy']) && $assoc['orderBy'] !== null) {
+                foreach ($assoc['orderBy'] AS $orderField => $orientation) {
+                    if (!$targetMetadata->hasField($orderField)) {
+                        $ce[] = "The association " . $class->name."#".$fieldName." is ordered by a foreign field " .
+                                $orderField . " that is not a field on the target entity " . $targetMetadata->name;
+                    }
+                }
+            }
+        }
+
+        foreach ($class->reflClass->getProperties(\ReflectionProperty::IS_PUBLIC) as $publicAttr) {
+            if ($publicAttr->isStatic()) {
+                continue;
+            }
+            $ce[] = "Field '".$publicAttr->getName()."' in class '".$class->name."' must be private ".
+                    "or protected. Public fields may break lazy-loading.";
+        }
+
+        foreach ($class->subClasses AS $subClass) {
+            if (!in_array($class->name, class_parents($subClass))) {
+                $ce[] = "According to the discriminator map class '" . $subClass . "' has to be a child ".
+                        "of '" . $class->name . "' but these entities are not related through inheritance.";
+            }
+        }
+
+        return $ce;
+    }
+
     /**
      * Check if the Database Schema is in sync with the current metadata state.
      *
@@ -230,6 +251,6 @@ class SchemaValidator
         $schemaTool = new SchemaTool($this->em);
 
         $allMetadata = $this->em->getMetadataFactory()->getAllMetadata();
-        return (count($schemaTool->getUpdateSchemaSql($allMetadata, false)) == 0);
+        return (count($schemaTool->getUpdateSchemaSql($allMetadata, true)) == 0);
     }
 }

lib/Doctrine/ORM/Tools/ToolsException.php

@@ -1,11 +1,38 @@
 <?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
 
 namespace Doctrine\ORM\Tools;
 
 use Doctrine\ORM\ORMException;
 
+/**
+ * Tools related Exceptions
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
 class ToolsException extends ORMException
 {
+    public static function schemaToolFailure($sql, \Exception $e)
+    {
+        return new self("Schema-Tool failed with Error '" . $e->getMessage() . "' while executing DDL: " . $sql, "0", $e);
+    }
+
     public static function couldNotMapDoctrine1Type($type)
     {
         return new self("Could not map doctrine 1 type '$type'!");

lib/vendor/doctrine-common

@@ -1 +1 @@
-Subproject commit ef431a14852d7e8f2d0ea789487509ab266e5ce2
+Subproject commit 9c880cf9ae2c14102568520b5ee885b03bda93e4

lib/vendor/doctrine-dbal

@@ -1 +1 @@
-Subproject commit f91395b6f469b5076f52fefd64574c443b076485
+Subproject commit 537de7ea6a34edbcc40bc6ca92e0a3f816b59330

tests/Doctrine/Tests/DbalTypes/NegativeToPositiveType.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Doctrine\Tests\DbalTypes;
+
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+class NegativeToPositiveType extends Type
+{
+    public function getName()
+    {
+        return 'negative_to_positive';
+    }
+
+    public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
+    {
+        return $platform->getIntegerTypeDeclarationSQL($fieldDeclaration);
+    }
+
+    public function canRequireSQLConversion()
+    {
+        return true;
+    }
+
+    public function convertToDatabaseValueSQL($sqlExpr, AbstractPlatform $platform)
+    {
+        return 'ABS(' . $sqlExpr . ')';
+    }
+
+    public function convertToPHPValueSQL($sqlExpr, $platform)
+    {
+        return '-(' . $sqlExpr . ')';
+    }
+}

tests/Doctrine/Tests/DbalTypes/UpperCaseStringType.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Doctrine\Tests\DbalTypes;
+
+use Doctrine\DBAL\Types\StringType;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+class UpperCaseStringType extends StringType
+{
+    public function getName()
+    {
+        return 'upper_case_string';
+    }
+
+    public function canRequireSQLConversion()
+    {
+        return true;
+    }
+
+    public function convertToDatabaseValueSQL($sqlExpr, AbstractPlatform $platform)
+    {
+        return 'UPPER(' . $sqlExpr . ')';
+    }
+
+    public function convertToPHPValueSQL($sqlExpr, $platform)
+    {
+        return 'LOWER(' . $sqlExpr . ')';
+    }
+}

tests/Doctrine/Tests/Mocks/ConnectionMock.php

@@ -8,7 +8,8 @@ class ConnectionMock extends \Doctrine\DBAL\Connection
     private $_platformMock;
     private $_lastInsertId = 0;
     private $_inserts = array();
-    
+    private $_executeUpdates = array();
+
     public function __construct(array $params, $driver, $config = null, $eventManager = null)
     {
         $this->_platformMock = new DatabasePlatformMock();
@@ -18,7 +19,7 @@ class ConnectionMock extends \Doctrine\DBAL\Connection
         // Override possible assignment of platform to database platform mock
         $this->_platform = $this->_platformMock;
     }
-    
+
     /**
      * @override
      */
@@ -26,15 +27,23 @@ class ConnectionMock extends \Doctrine\DBAL\Connection
     {
         return $this->_platformMock;
     }
-    
+
     /**
      * @override
      */
-    public function insert($tableName, array $data)
+    public function insert($tableName, array $data, array $types = array())
     {
         $this->_inserts[$tableName][] = $data;
     }
-    
+
+    /**
+     * @override
+     */
+    public function executeUpdate($query, array $params = array(), array $types = array())
+    {
+        $this->_executeUpdates[] = array('query' => $query, 'params' => $params, 'types' => $types);
+    }
+
     /**
      * @override
      */
@@ -50,7 +59,7 @@ class ConnectionMock extends \Doctrine\DBAL\Connection
     {
         return $this->_fetchOneResult;
     }
-    
+
     /**
      * @override
      */
@@ -61,29 +70,34 @@ class ConnectionMock extends \Doctrine\DBAL\Connection
         }
         return $input;
     }
-    
+
     /* Mock API */
 
     public function setFetchOneResult($fetchOneResult)
     {
         $this->_fetchOneResult = $fetchOneResult;
     }
-    
+
     public function setDatabasePlatform($platform)
     {
         $this->_platformMock = $platform;
     }
-    
+
     public function setLastInsertId($id)
     {
         $this->_lastInsertId = $id;
     }
-    
+
     public function getInserts()
     {
         return $this->_inserts;
     }
-    
+
+    public function getExecuteUpdates()
+    {
+        return $this->_executeUpdates;
+    }
+
     public function reset()
     {
         $this->_inserts = array();

tests/Doctrine/Tests/Mocks/DatabasePlatformMock.php

@@ -57,7 +57,7 @@ class DatabasePlatformMock extends \Doctrine\DBAL\Platforms\AbstractPlatform
 
     /** @override */
     public function getVarcharTypeDeclarationSQL(array $field) {}
-    
+
     /** @override */
     public function getClobTypeDeclarationSQL(array $field) {}
 
@@ -85,6 +85,13 @@ class DatabasePlatformMock extends \Doctrine\DBAL\Platforms\AbstractPlatform
 
     protected function initializeDoctrineTypeMappings()
     {
-        
+
+    }
+    /**
+     * Gets the SQL Snippet used to declare a BLOB column type.
+     */
+    public function getBlobTypeDeclarationSQL(array $field)
+    {
+        throw DBALException::notSupported(__METHOD__);
     }
 }

tests/Doctrine/Tests/Mocks/HydratorMockStatement.php

@@ -8,10 +8,10 @@ namespace Doctrine\Tests\Mocks;
  *
  * @author  Roman Borschel <roman@code-factory.org>
  */
-class HydratorMockStatement implements \Doctrine\DBAL\Driver\Statement
+class HydratorMockStatement implements \IteratorAggregate, \Doctrine\DBAL\Driver\Statement
 {
-    private $_resultSet;    
-    
+    private $_resultSet;
+
     /**
      * Creates a new mock statement that will serve the provided fake result set to clients.
      *
@@ -21,7 +21,7 @@ class HydratorMockStatement implements \Doctrine\DBAL\Driver\Statement
     {
         $this->_resultSet = $resultSet;
     }
-    
+
     /**
      * Fetches all rows from the result set.
      *
@@ -31,7 +31,7 @@ class HydratorMockStatement implements \Doctrine\DBAL\Driver\Statement
     {
         return $this->_resultSet;
     }
-    
+
     public function fetchColumn($columnNumber = 0)
     {
         $row = current($this->_resultSet);
@@ -39,10 +39,10 @@ class HydratorMockStatement implements \Doctrine\DBAL\Driver\Statement
         $val = array_shift($row);
         return $val !== null ? $val : false;
     }
-    
+
     /**
      * Fetches the next row in the result set.
-     * 
+     *
      */
     public function fetch($fetchStyle = null)
     {
@@ -50,7 +50,7 @@ class HydratorMockStatement implements \Doctrine\DBAL\Driver\Statement
         next($this->_resultSet);
         return $current;
     }
-    
+
     /**
      * Closes the cursor, enabling the statement to be executed again.
      *
@@ -60,13 +60,13 @@ class HydratorMockStatement implements \Doctrine\DBAL\Driver\Statement
     {
         return true;
     }
-    
+
     public function setResultSet(array $resultSet)
     {
         reset($resultSet);
         $this->_resultSet = $resultSet;
     }
-    
+
     public function bindColumn($column, &$param, $type = null)
     {
     }
@@ -78,7 +78,7 @@ class HydratorMockStatement implements \Doctrine\DBAL\Driver\Statement
     public function bindParam($column, &$variable, $type = null, $length = null, $driverOptions = array())
     {
     }
-    
+
     public function columnCount()
     {
     }
@@ -86,16 +86,26 @@ class HydratorMockStatement implements \Doctrine\DBAL\Driver\Statement
     public function errorCode()
     {
     }
-    
+
     public function errorInfo()
     {
     }
-    
+
     public function execute($params = array())
     {
     }
-    
+
     public function rowCount()
     {
-    }  
+    }
+
+    public function getIterator()
+    {
+        return $this->_resultSet;
+    }
+
+    public function setFetchMode($fetchMode)
+    {
+        
+    }
 }

tests/Doctrine/Tests/Models/CMS/CmsAddress.php

@@ -46,7 +46,7 @@ class CmsAddress
     public function getId() {
         return $this->id;
     }
-    
+
     public function getUser() {
         return $this->user;
     }
@@ -62,7 +62,7 @@ class CmsAddress
     public function getCity() {
         return $this->city;
     }
-    
+
     public function setUser(CmsUser $user) {
         if ($this->user !== $user) {
             $this->user = $user;

tests/Doctrine/Tests/Models/CustomType/CustomTypeChild.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Doctrine\Tests\Models\CustomType;
+
+/**
+ * @Entity
+ * @Table(name="customtype_children")
+ */
+class CustomTypeChild
+{
+    /**
+     * @Id @Column(type="integer")
+     * @GeneratedValue(strategy="AUTO")
+     */
+    public $id;
+
+    /**
+     * @Column(type="upper_case_string")
+     */
+    public $lowerCaseString = 'foo';
+}

tests/Doctrine/Tests/Models/CustomType/CustomTypeParent.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Doctrine\Tests\Models\CustomType;
+
+/**
+ * @Entity
+ * @Table(name="customtype_parents")
+ */
+class CustomTypeParent
+{
+    /**
+     * @Id @Column(type="integer")
+     * @GeneratedValue(strategy="AUTO")
+     */
+    public $id;
+
+    /**
+     * @Column(type="negative_to_positive", nullable=true)
+     */
+    public $customInteger;
+
+    /**
+     * @OneToOne(targetEntity="Doctrine\Tests\Models\CustomType\CustomTypeChild", cascade={"persist", "remove"})
+     */
+    public $child;
+
+    /**
+     * @ManyToMany(targetEntity="Doctrine\Tests\Models\CustomType\CustomTypeParent", mappedBy="myFriends")
+     */
+    private $friendsWithMe;
+
+    /**
+     * @ManyToMany(targetEntity="Doctrine\Tests\Models\CustomType\CustomTypeParent", inversedBy="friendsWithMe")
+     * @JoinTable(
+     *     name="customtype_parent_friends",
+     *     joinColumns={@JoinColumn(name="customtypeparent_id", referencedColumnName="id")},
+     *     inverseJoinColumns={@JoinColumn(name="friend_customtypeparent_id", referencedColumnName="id")}
+     * )
+     */
+    private $myFriends;
+
+    public function __construct()
+    {
+        $this->friendsWithMe = new \Doctrine\Common\Collections\ArrayCollection();
+        $this->myFriends = new \Doctrine\Common\Collections\ArrayCollection();
+    }
+
+    public function addMyFriend(CustomTypeParent $friend)
+    {
+        $this->getMyFriends()->add($friend);
+        $friend->addFriendWithMe($this);
+    }
+
+    public function getMyFriends()
+    {
+        return $this->myFriends;
+    }
+
+    public function addFriendWithMe(CustomTypeParent $friend)
+    {
+        $this->getFriendsWithMe()->add($friend);
+    }
+
+    public function getFriendsWithMe()
+    {
+        return $this->friendsWithMe;
+    }
+}

tests/Doctrine/Tests/Models/CustomType/CustomTypeUpperCase.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Doctrine\Tests\Models\CustomType;
+
+/**
+ * @Entity
+ * @Table(name="customtype_uppercases")
+ */
+class CustomTypeUpperCase
+{
+    /**
+     * @Id @Column(type="integer")
+     * @GeneratedValue(strategy="AUTO")
+     */
+    public $id;
+
+    /**
+     * @Column(type="upper_case_string")
+     */
+    public $lowerCaseString;
+}

tests/Doctrine/Tests/Models/DDC117/DDC117Article.php

@@ -9,6 +9,7 @@ class DDC117Article
 {
     /** @Id @Column(type="integer", name="article_id") @GeneratedValue */
     private $id;
+    
     /** @Column */
     private $title;
 

tests/Doctrine/Tests/Models/DDC1476/DDC1476EntityWithDefaultFieldType.php

@@ -0,0 +1,76 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Tests\Models\DDC1476;
+
+/**
+ * @Entity()
+ */
+class DDC1476EntityWithDefaultFieldType
+{
+
+    /**
+     * @Id 
+     * @Column() 
+     * @GeneratedValue("NONE")
+     */
+    protected $id;
+
+    /** @column() */
+    protected $name;
+
+    /**
+     * @return integer 
+     */
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return string 
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @param string $name 
+     */
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+    
+    public static function loadMetadata(\Doctrine\ORM\Mapping\ClassMetadataInfo $metadata)
+    {
+        $metadata->mapField(array(
+           'id'         => true,
+           'fieldName'  => 'id',
+        ));
+        $metadata->mapField(array(
+           'fieldName'  => 'name',
+        ));
+        
+        $metadata->setIdGeneratorType(\Doctrine\ORM\Mapping\ClassMetadataInfo::GENERATOR_TYPE_NONE);
+    }
+
+}

tests/Doctrine/Tests/Models/Legacy/LegacyUser.php

@@ -21,7 +21,7 @@ class LegacyUser
      */
     public $_username;
     /**
-     * @Column(type="string", length=255)
+     * @Column(type="string", length=255, name="name")
      */
     public $_name;
     /**

tests/Doctrine/Tests/Models/Legacy/LegacyUserReference.php

@@ -23,12 +23,12 @@ class LegacyUserReference
     private $_target;
 
     /**
-     * @column(type="string")
+     * @column(type="string", name="description")
      */
     private $_description;
 
     /**
-     * @column(type="datetime")
+     * @column(type="datetime", name="created")
      */
     private $_created;
 

tests/Doctrine/Tests/ORM/Functional/BasicFunctionalTest.php

@@ -1030,4 +1030,173 @@ class BasicFunctionalTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $this->assertEquals(\Doctrine\ORM\UnitOfWork::STATE_DETACHED, $unitOfWork->getEntityState($address));
     }
+
+    /**
+     * @group DDC-720
+     */
+    public function testFlushSingleManagedEntity()
+    {
+        $user = new CmsUser;
+        $user->name = 'Dominik';
+        $user->username = 'domnikl';
+        $user->status = 'developer';
+
+        $this->_em->persist($user);
+        $this->_em->flush();
+
+        $user->status = 'administrator';
+        $this->_em->flush($user);
+        $this->_em->clear();
+
+        $user = $this->_em->find(get_class($user), $user->id);
+        $this->assertEquals('administrator', $user->status);
+    }
+
+    /**
+     * @group DDC-720
+     */
+    public function testFlushSingleUnmanagedEntity()
+    {
+        $user = new CmsUser;
+        $user->name = 'Dominik';
+        $user->username = 'domnikl';
+        $user->status = 'developer';
+
+        $this->setExpectedException('InvalidArgumentException', 'Entity has to be managed for single computation');
+        $this->_em->flush($user);
+    }
+
+    /**
+     * @group DDC-720
+     */
+    public function testFlushSingleAndNewEntity()
+    {
+        $user = new CmsUser;
+        $user->name = 'Dominik';
+        $user->username = 'domnikl';
+        $user->status = 'developer';
+
+        $this->_em->persist($user);
+        $this->_em->flush();
+
+        $otherUser = new CmsUser;
+        $otherUser->name = 'Dominik2';
+        $otherUser->username = 'domnikl2';
+        $otherUser->status = 'developer';
+
+        $user->status = 'administrator';
+
+        $this->_em->persist($otherUser);
+        $this->_em->flush($user);
+
+        $this->assertTrue($this->_em->contains($otherUser), "Other user is contained in EntityManager");
+        $this->assertTrue($otherUser->id > 0, "other user has an id");
+    }
+
+    /**
+     * @group DDC-720
+     */
+    public function testFlushAndCascadePersist()
+    {
+        $user = new CmsUser;
+        $user->name = 'Dominik';
+        $user->username = 'domnikl';
+        $user->status = 'developer';
+
+        $this->_em->persist($user);
+        $this->_em->flush();
+
+        $address = new CmsAddress();
+        $address->city = "Springfield";
+        $address->zip = "12354";
+        $address->country = "Germany";
+        $address->street = "Foo Street";
+        $address->user = $user;
+        $user->address = $address;
+
+        $this->_em->flush($user);
+
+        $this->assertTrue($this->_em->contains($address), "Other user is contained in EntityManager");
+        $this->assertTrue($address->id > 0, "other user has an id");
+    }
+
+    /**
+     * @group DDC-720
+     */
+    public function testFlushSingleAndNoCascade()
+    {
+        $user = new CmsUser;
+        $user->name = 'Dominik';
+        $user->username = 'domnikl';
+        $user->status = 'developer';
+
+        $this->_em->persist($user);
+        $this->_em->flush();
+
+        $article1 = new CmsArticle();
+        $article1->topic = 'Foo';
+        $article1->text = 'Foo Text';
+        $article1->author = $user;
+        $user->articles[] = $article1;
+
+        $this->setExpectedException('InvalidArgumentException', "A new entity was found through the relationship 'Doctrine\Tests\Models\CMS\CmsUser#articles'");
+        $this->_em->flush($user);
+    }
+
+    /**
+     * @group DDC-720
+     */
+    public function testProxyIsIgnored()
+    {
+        $user = new CmsUser;
+        $user->name = 'Dominik';
+        $user->username = 'domnikl';
+        $user->status = 'developer';
+
+        $this->_em->persist($user);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $user = $this->_em->getReference(get_class($user), $user->id);
+
+        $otherUser = new CmsUser;
+        $otherUser->name = 'Dominik2';
+        $otherUser->username = 'domnikl2';
+        $otherUser->status = 'developer';
+
+        $this->_em->persist($otherUser);
+        $this->_em->flush($user);
+
+        $this->assertTrue($this->_em->contains($otherUser), "Other user is contained in EntityManager");
+        $this->assertTrue($otherUser->id > 0, "other user has an id");
+    }
+
+    /**
+     * @group DDC-720
+     */
+    public function testFlushSingleSaveOnlySingle()
+    {
+        $user = new CmsUser;
+        $user->name = 'Dominik';
+        $user->username = 'domnikl';
+        $user->status = 'developer';
+        $this->_em->persist($user);
+
+        $user2 = new CmsUser;
+        $user2->name = 'Dominik';
+        $user2->username = 'domnikl2';
+        $user2->status = 'developer';
+        $this->_em->persist($user2);
+
+        $this->_em->flush();
+
+        $user->status = 'admin';
+        $user2->status = 'admin';
+
+        $this->_em->flush($user);
+        $this->_em->clear();
+
+        $user2 = $this->_em->find(get_class($user2), $user2->id);
+        $this->assertEquals('developer', $user2->status);
+    }
 }

tests/Doctrine/Tests/ORM/Functional/CustomTreeWalkersTest.php

@@ -1,7 +1,5 @@
 <?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
@@ -33,11 +31,13 @@ require_once __DIR__ . '/../../TestInit.php';
  * @link        http://www.doctrine-project.org
  * @since       2.0
  */
-class CustomTreeWalkersTest extends \Doctrine\Tests\OrmFunctionalTestCase
+class CustomTreeWalkersTest extends \Doctrine\Tests\OrmTestCase
 {
-    protected function setUp() {
-        $this->useModelSet('cms');
-        parent::setUp();
+    private $_em;
+
+    protected function setUp()
+    {
+        $this->_em = $this->_getTestEntityManager();
     }
 
     public function assertSqlGeneration($dqlToBeTested, $sqlToBeConfirmed)
@@ -70,7 +70,7 @@ class CustomTreeWalkersTest extends \Doctrine\Tests\OrmFunctionalTestCase
             "SELECT c0_.id AS id0, c0_.status AS status1, c0_.username AS username2, c0_.name AS name3, c0_.email_id AS email_id4 FROM cms_users c0_ WHERE (c0_.name = ? OR c0_.name = ?) AND c0_.id = 1"
         );
     }
-    
+
     public function testSupportsQueriesWithSimpleConditionalExpression()
     {
         $this->assertSqlGeneration(
@@ -94,7 +94,7 @@ class CustomTreeWalker extends Query\TreeWalkerAdapter
                 $dqlAliases[] = $dqlAlias;
             }
         }
-        
+
         // Create our conditions for all involved classes
         $factors = array();
         foreach ($dqlAliases as $alias) {
@@ -108,7 +108,7 @@ class CustomTreeWalker extends Query\TreeWalkerAdapter
             $factor = new Query\AST\ConditionalFactor($condPrimary);
             $factors[] = $factor;
         }
-        
+
         if (($whereClause = $selectStatement->whereClause) !== null) {
             // There is already a WHERE clause, so append the conditions
             $condExpr = $whereClause->conditionalExpression;
@@ -119,18 +119,18 @@ class CustomTreeWalker extends Query\TreeWalkerAdapter
 
                 $whereClause->conditionalExpression = $condExpr;
             }
-            
+
             $existingTerms = $whereClause->conditionalExpression->conditionalTerms;
-            
+
             if (count($existingTerms) > 1) {
                 // More than one term, so we need to wrap all these terms in a single root term
                 // i.e: "WHERE u.name = :foo or u.other = :bar" => "WHERE (u.name = :foo or u.other = :bar) AND <our condition>"
-                
+
                 $primary = new Query\AST\ConditionalPrimary;
                 $primary->conditionalExpression = new Query\AST\ConditionalExpression($existingTerms);
                 $existingFactor = new Query\AST\ConditionalFactor($primary);
                 $term = new Query\AST\ConditionalTerm(array_merge(array($existingFactor), $factors));
-                
+
                 $selectStatement->whereClause->conditionalExpression->conditionalTerms = array($term);
             } else {
                 // Just one term so we can simply append our factors to that term

tests/Doctrine/Tests/ORM/Functional/DatabaseDriverTest.php

@@ -98,7 +98,7 @@ class DatabaseDriverTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertArrayHasKey('CmsUsers', $metadatas, 'CmsUsers entity was not detected.');
         $this->assertArrayHasKey('CmsGroups', $metadatas, 'CmsGroups entity was not detected.');
 
-        $this->assertEquals(1, count($metadatas['CmsUsers']->associationMappings));
+        $this->assertEquals(2, count($metadatas['CmsUsers']->associationMappings));
         $this->assertArrayHasKey('group', $metadatas['CmsUsers']->associationMappings);
         $this->assertEquals(1, count($metadatas['CmsGroups']->associationMappings));
         $this->assertArrayHasKey('user', $metadatas['CmsGroups']->associationMappings);

tests/Doctrine/Tests/ORM/Functional/EntityRepositoryTest.php

@@ -20,7 +20,9 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
     public function tearDown()
     {
-        $this->_em->getConfiguration()->setEntityNamespaces(array());
+        if ($this->_em) {
+            $this->_em->getConfiguration()->setEntityNamespaces(array());
+        }
         parent::tearDown();
     }
 
@@ -78,7 +80,7 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         return array($user->id, $address->id);
     }
-    
+
     public function buildUser($name, $username, $status, $address)
     {
         $user = new CmsUser();
@@ -89,10 +91,10 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $this->_em->persist($user);
         $this->_em->flush();
-        
+
         return $user;
     }
-    
+
     public function buildAddress($country, $city, $street, $zip)
     {
         $address = new CmsAddress();
@@ -103,7 +105,7 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $this->_em->persist($address);
         $this->_em->flush();
-        
+
         return $address;
     }
 
@@ -134,22 +136,22 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
     {
         $address1 = $this->buildAddress('Germany', 'Berlim', 'Foo st.', '123456');
         $user1    = $this->buildUser('Benjamin', 'beberlei', 'dev', $address1);
-        
+
         $address2 = $this->buildAddress('Brazil', 'São Paulo', 'Bar st.', '654321');
         $user2    = $this->buildUser('Guilherme', 'guilhermeblanco', 'freak', $address2);
-        
+
         $address3 = $this->buildAddress('USA', 'Nashville', 'Woo st.', '321654');
         $user3    = $this->buildUser('Jonathan', 'jwage', 'dev', $address3);
-        
+
         unset($address1);
         unset($address2);
         unset($address3);
-        
+
         $this->_em->clear();
-        
+
         $repository = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsAddress');
         $addresses  = $repository->findBy(array('user' => array($user1->getId(), $user2->getId())));
-        
+
         $this->assertEquals(2, count($addresses));
         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsAddress',$addresses[0]);
     }
@@ -158,22 +160,22 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
     {
         $address1 = $this->buildAddress('Germany', 'Berlim', 'Foo st.', '123456');
         $user1    = $this->buildUser('Benjamin', 'beberlei', 'dev', $address1);
-        
+
         $address2 = $this->buildAddress('Brazil', 'São Paulo', 'Bar st.', '654321');
         $user2    = $this->buildUser('Guilherme', 'guilhermeblanco', 'freak', $address2);
-        
+
         $address3 = $this->buildAddress('USA', 'Nashville', 'Woo st.', '321654');
         $user3    = $this->buildUser('Jonathan', 'jwage', 'dev', $address3);
-        
+
         unset($address1);
         unset($address2);
         unset($address3);
-        
+
         $this->_em->clear();
-        
+
         $repository = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsAddress');
         $addresses  = $repository->findBy(array('user' => array($user1, $user2)));
-        
+
         $this->assertEquals(2, count($addresses));
         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsAddress',$addresses[0]);
     }
@@ -189,7 +191,7 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertEquals('Guilherme', $users[0]->name);
         $this->assertEquals('dev', $users[0]->status);
     }
-    
+
     public function testFindAll()
     {
         $user1Id = $this->loadFixture();
@@ -280,7 +282,7 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $userId = $user->id;
 
         $this->_em->find('Doctrine\Tests\Models\CMS\CmsUser', $userId);
-        
+
         $this->setExpectedException('Doctrine\ORM\OptimisticLockException');
         $this->_em->find('Doctrine\Tests\Models\CMS\CmsUser', $userId, \Doctrine\DBAL\LockMode::OPTIMISTIC);
     }
@@ -423,7 +425,7 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
     public function testFindByLimitOffset()
     {
         $this->loadFixture();
-        
+
         $repos = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsUser');
 
         $users1 = $repos->findBy(array(), null, 1, 0);
@@ -451,8 +453,8 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertSame($usersAsc[0], $usersDesc[2]);
         $this->assertSame($usersAsc[2], $usersDesc[0]);
     }
-    
-    
+
+
     /**
      * @group DDC-753
      */
@@ -465,19 +467,19 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $repos = $this->_em->getRepository('Doctrine\Tests\Models\DDC753\DDC753EntityWithDefaultCustomRepository');
         $this->assertInstanceOf("Doctrine\Tests\Models\DDC753\DDC753DefaultRepository", $repos);
         $this->assertTrue($repos->isDefaultRepository());
-        
-        
+
+
         $repos = $this->_em->getRepository('Doctrine\Tests\Models\DDC753\DDC753EntityWithCustomRepository');
         $this->assertInstanceOf("Doctrine\Tests\Models\DDC753\DDC753CustomRepository", $repos);
         $this->assertTrue($repos->isCustomRepository());
-        
+
         $this->assertEquals($this->_em->getConfiguration()->getDefaultRepositoryClassName(), "Doctrine\Tests\Models\DDC753\DDC753DefaultRepository");
         $this->_em->getConfiguration()->setDefaultRepositoryClassName("Doctrine\ORM\EntityRepository");
         $this->assertEquals($this->_em->getConfiguration()->getDefaultRepositoryClassName(), "Doctrine\ORM\EntityRepository");
 
     }
-    
-    
+
+
     /**
      * @group DDC-753
      * @expectedException Doctrine\ORM\ORMException
@@ -488,6 +490,16 @@ class EntityRepositoryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertEquals($this->_em->getConfiguration()->getDefaultRepositoryClassName(), "Doctrine\ORM\EntityRepository");
         $this->_em->getConfiguration()->setDefaultRepositoryClassName("Doctrine\Tests\Models\DDC753\DDC753InvalidRepository");
     }
-    
+
+    /**
+     * @group DDC-1500
+     */
+    public function testInvalidOrientation()
+    {
+        $this->setExpectedException('Doctrine\ORM\ORMException', 'Invalid order by orientation specified for Doctrine\Tests\Models\CMS\CmsUser#username');
+
+        $repo = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsUser');
+        $repo->findBy(array('status' => 'test'), array('username' => 'INVALID'));
+    }
 }
 

tests/Doctrine/Tests/ORM/Functional/ExtraLazyCollectionTest.php

@@ -29,7 +29,7 @@ class ExtraLazyCollectionTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $class = $this->_em->getClassMetadata('Doctrine\Tests\Models\CMS\CmsGroup');
         $class->associationMappings['users']['fetch'] = ClassMetadataInfo::FETCH_EXTRA_LAZY;
 
-        
+
         $this->loadFixture();
     }
 
@@ -137,9 +137,9 @@ class ExtraLazyCollectionTest extends \Doctrine\Tests\OrmFunctionalTestCase
     {
         $user = $this->_em->find('Doctrine\Tests\Models\CMS\CmsUser', $this->userId);
         $this->assertFalse($user->groups->isInitialized(), "Pre-Condition: Collection is not initialized.");
-        
+
         $queryCount = $this->getCurrentQueryCount();
-        
+
         $someGroups = $user->groups->slice(0, 2);
 
         $this->assertContainsOnly('Doctrine\Tests\Models\CMS\CmsGroup', $someGroups);
@@ -225,7 +225,7 @@ class ExtraLazyCollectionTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($user->articles->isInitialized(), "Pre-Condition: Collection is not initialized.");
 
         $article = $this->_em->find('Doctrine\Tests\Models\CMS\CmsArticle', $this->articleId);
-        
+
         $queryCount = $this->getCurrentQueryCount();
         $this->assertTrue($user->articles->contains($article));
         $this->assertFalse($user->articles->isInitialized(), "Post-Condition: Collection is not initialized.");
@@ -304,6 +304,49 @@ class ExtraLazyCollectionTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($user->groups->isInitialized(), "Post-Condition: Collection is not initialized.");
     }
 
+    /**
+     * @group DDC-1399
+     */
+    public function testCountAfterAddThenFlush()
+    {
+        $user = $this->_em->find('Doctrine\Tests\Models\CMS\CmsUser', $this->userId);
+
+        $newGroup = new \Doctrine\Tests\Models\CMS\CmsGroup();
+        $newGroup->name = "Test4";
+
+        $user->addGroup($newGroup);
+        $this->_em->persist($newGroup);
+
+        $this->assertFalse($user->groups->isInitialized());
+        $this->assertEquals(4, count($user->groups));
+        $this->assertFalse($user->groups->isInitialized());
+
+        $this->_em->flush();
+
+        $this->assertEquals(4, count($user->groups));
+    }
+
+    /**
+     * @group DDC-1462
+     */
+    public function testSliceOnDirtyCollection()
+    {
+        $user = $this->_em->find('Doctrine\Tests\Models\CMS\CmsUser', $this->userId);
+        /* @var $user CmsUser */
+
+        $newGroup = new \Doctrine\Tests\Models\CMS\CmsGroup();
+        $newGroup->name = "Test4";
+
+        $user->addGroup($newGroup);
+        $this->_em->persist($newGroup);
+
+        $qc = $this->getCurrentQueryCount();
+        $groups = $user->groups->slice(0, 10);
+
+        $this->assertEquals(4, count($groups));
+        $this->assertEquals($qc + 1, $this->getCurrentQueryCount());
+    }
+
     private function loadFixture()
     {
         $user1 = new \Doctrine\Tests\Models\CMS\CmsUser();
@@ -364,7 +407,7 @@ class ExtraLazyCollectionTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $this->_em->persist($article1);
         $this->_em->persist($article2);
-        
+
         $this->_em->flush();
         $this->_em->clear();
 

tests/Doctrine/Tests/ORM/Functional/LifecycleCallbackTest.php

@@ -43,6 +43,29 @@ class LifecycleCallbackTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertEquals('changed from preUpdate callback!', $result[0]->value);
     }
     
+    public function testPreFlushCallbacksAreInvoked()
+    {
+        $entity = new LifecycleCallbackTestEntity;
+        $entity->value = 'hello';
+        $this->_em->persist($entity);
+
+        $this->_em->flush();
+
+        $this->assertTrue($entity->prePersistCallbackInvoked);
+        $this->assertTrue($entity->preFlushCallbackInvoked);
+
+        $entity->preFlushCallbackInvoked = false;
+        $this->_em->flush();
+
+        $this->assertTrue($entity->preFlushCallbackInvoked);
+
+        $entity->value = 'bye';
+        $entity->preFlushCallbackInvoked = false;
+        $this->_em->flush();
+
+        $this->assertTrue($entity->preFlushCallbackInvoked);
+    }
+
     public function testChangesDontGetLost()
     {
         $user = new LifecycleCallbackTestUser;
@@ -190,6 +213,8 @@ class LifecycleCallbackTestEntity
     public $postPersistCallbackInvoked = false;
     public $postLoadCallbackInvoked = false;
     
+    public $preFlushCallbackInvoked = false;
+
     /**
      * @Id @Column(type="integer")
      * @GeneratedValue(strategy="AUTO")
@@ -233,6 +258,11 @@ class LifecycleCallbackTestEntity
     public function doStuffOnPreUpdate() {
         $this->value = 'changed from preUpdate callback!';
     }
+
+    /** @PreFlush */
+    public function doStuffOnPreFlush() {
+        $this->preFlushCallbackInvoked = true;
+    }
 }
 
 /**

tests/Doctrine/Tests/ORM/Functional/MappedSuperclassTest.php

@@ -39,6 +39,7 @@ class MappedSuperclassTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $cleanFile = $this->_em->find(get_class($file), $file->getId());
 
         $this->assertInstanceOf('Doctrine\Tests\Models\DirectoryTree\Directory', $cleanFile->getParent());
+        $this->assertInstanceOf('Doctrine\ORM\Proxy\Proxy', $cleanFile->getParent());
         $this->assertEquals($directory->getId(), $cleanFile->getParent()->getId());
         $this->assertInstanceOf('Doctrine\Tests\Models\DirectoryTree\Directory', $cleanFile->getParent()->getParent());
         $this->assertEquals($root->getId(), $cleanFile->getParent()->getParent()->getId());

tests/Doctrine/Tests/ORM/Functional/NativeQueryTest.php

@@ -35,7 +35,7 @@ class NativeQueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $user->status = 'dev';
         $this->_em->persist($user);
         $this->_em->flush();
-        
+
         $this->_em->clear();
 
         $rsm = new ResultSetMapping;
@@ -94,24 +94,24 @@ class NativeQueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertEquals($addr->street, $addresses[0]->street);
         $this->assertTrue($addresses[0]->user instanceof CmsUser);
     }
-    
+
     public function testJoinedOneToManyNativeQuery()
     {
         $user = new CmsUser;
         $user->name = 'Roman';
         $user->username = 'romanb';
         $user->status = 'dev';
-        
+
         $phone = new CmsPhonenumber;
         $phone->phonenumber = 424242;
-        
+
         $user->addPhonenumber($phone);
-        
+
         $this->_em->persist($user);
         $this->_em->flush();
-        
+
         $this->_em->clear();
-        
+
         $rsm = new ResultSetMapping;
         $rsm->addEntityResult('Doctrine\Tests\Models\CMS\CmsUser', 'u');
         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('id'), 'id');
@@ -119,7 +119,7 @@ class NativeQueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('status'), 'status');
         $rsm->addJoinedEntityResult('Doctrine\Tests\Models\CMS\CmsPhonenumber', 'p', 'u', 'phonenumbers');
         $rsm->addFieldResult('p', $this->platform->getSQLResultCasing('phonenumber'), 'phonenumber');
-        
+
         $query = $this->_em->createNativeQuery('SELECT id, name, status, phonenumber FROM cms_users INNER JOIN cms_phonenumbers ON id = user_id WHERE username = ?', $rsm);
         $query->setParameter(1, 'romanb');
 
@@ -133,30 +133,30 @@ class NativeQueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $phones = $users[0]->getPhonenumbers();
         $this->assertEquals(424242, $phones[0]->phonenumber);
         $this->assertTrue($phones[0]->getUser() === $users[0]);
-        
+
     }
-    
+
     public function testJoinedOneToOneNativeQuery()
     {
         $user = new CmsUser;
         $user->name = 'Roman';
         $user->username = 'romanb';
         $user->status = 'dev';
-        
+
         $addr = new CmsAddress;
         $addr->country = 'germany';
         $addr->zip = 10827;
         $addr->city = 'Berlin';
-        
-        
+
+
         $user->setAddress($addr);
-        
+
         $this->_em->persist($user);
         $this->_em->flush();
-        
+
         $this->_em->clear();
-        
-        
+
+
         $rsm = new ResultSetMapping;
         $rsm->addEntityResult('Doctrine\Tests\Models\CMS\CmsUser', 'u');
         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('id'), 'id');
@@ -167,12 +167,12 @@ class NativeQueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('country'), 'country');
         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('zip'), 'zip');
         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('city'), 'city');
-        
+
         $query = $this->_em->createNativeQuery('SELECT u.id, u.name, u.status, a.id AS a_id, a.country, a.zip, a.city FROM cms_users u INNER JOIN cms_addresses a ON u.id = a.user_id WHERE u.username = ?', $rsm);
         $query->setParameter(1, 'romanb');
-        
+
         $users = $query->getResult();
-        
+
         $this->assertEquals(1, count($users));
         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
         $this->assertEquals('Roman', $users[0]->name);

tests/Doctrine/Tests/ORM/Functional/OneToManyOrphanRemovalTest.php

@@ -13,46 +13,63 @@ require_once __DIR__ . '/../../TestInit.php';
  */
 class OneToManyOrphanRemovalTest extends \Doctrine\Tests\OrmFunctionalTestCase
 {
+    protected $userId;
+
     protected function setUp()
     {
         $this->useModelSet('cms');
-        
+
         parent::setUp();
-    }
-    
-    public function testOrphanRemoval()
-    {
+
         $user = new CmsUser;
         $user->status = 'dev';
         $user->username = 'romanb';
         $user->name = 'Roman B.';
-        
+
         $phone = new CmsPhonenumber;
         $phone->phonenumber = '123456';
-        
+
         $user->addPhonenumber($phone);
-        
+
         $this->_em->persist($user);
         $this->_em->flush();
-        
-        $userId = $user->getId();
-        
+
+        $this->userId = $user->getId();
         $this->_em->clear();
-        
-        $userProxy = $this->_em->getReference('Doctrine\Tests\Models\CMS\CmsUser', $userId);
-        
+    }
+
+    public function testOrphanRemoval()
+    {
+        $userProxy = $this->_em->getReference('Doctrine\Tests\Models\CMS\CmsUser', $this->userId);
+
         $this->_em->remove($userProxy);
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $query  = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u');
         $result = $query->getResult();
-        
+
         $this->assertEquals(0, count($result), 'CmsUser should be removed by EntityManager');
-        
+
         $query  = $this->_em->createQuery('SELECT p FROM Doctrine\Tests\Models\CMS\CmsPhonenumber p');
         $result = $query->getResult();
-        
+
+        $this->assertEquals(0, count($result), 'CmsPhonenumber should be removed by orphanRemoval');
+    }
+
+    /**
+     * @group DDC-1496
+     */
+    public function testOrphanRemovalUnitializedCollection()
+    {
+        $user = $this->_em->find('Doctrine\Tests\Models\CMS\CmsUser', $this->userId);
+
+        $user->phonenumbers->clear();
+        $this->_em->flush();
+
+        $query  = $this->_em->createQuery('SELECT p FROM Doctrine\Tests\Models\CMS\CmsPhonenumber p');
+        $result = $query->getResult();
+
         $this->assertEquals(0, count($result), 'CmsPhonenumber should be removed by orphanRemoval');
     }
 }

tests/Doctrine/Tests/ORM/Functional/OneToManyUnidirectionalAssociationTest.php

@@ -73,7 +73,14 @@ class OneToManyUnidirectionalAssociationTest extends \Doctrine\Tests\OrmFunction
         $this->_em->persist($routeA);
         $this->_em->persist($routeB);
 
-        $this->setExpectedException('Exception'); // depends on the underyling Database Driver
-        $this->_em->flush(); // Exception
+        $exceptionThrown = false;
+        try {
+            // exception depending on the underyling Database Driver
+            $this->_em->flush();
+        } catch(\Exception $e) {
+            $exceptionThrown = true;
+        }
+
+        $this->assertTrue($exceptionThrown, "The underlying database driver throws an exception.");
     }
-}
+}

tests/Doctrine/Tests/ORM/Functional/OneToOneEagerLoadingTest.php

@@ -19,6 +19,7 @@ class OneToOneEagerLoadingTest extends \Doctrine\Tests\OrmFunctionalTestCase
             $schemaTool->createSchema(array(
                 $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\Train'),
                 $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\TrainDriver'),
+                $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\TrainOwner'),
                 $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\Waggon'),
             ));
         } catch(\Exception $e) {}
@@ -26,7 +27,7 @@ class OneToOneEagerLoadingTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
     public function testEagerLoadOneToOneOwningSide()
     {
-        $train = new Train();
+        $train = new Train(new TrainOwner("Alexander"));
         $driver = new TrainDriver("Benjamin");
         $waggon = new Waggon();
         
@@ -48,7 +49,7 @@ class OneToOneEagerLoadingTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
     public function testEagerLoadOneToOneNullOwningSide()
     {
-        $train = new Train();
+        $train = new Train(new TrainOwner("Alexander"));
 
         $this->_em->persist($train); // cascades
         $this->_em->flush();
@@ -65,9 +66,8 @@ class OneToOneEagerLoadingTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
     public function testEagerLoadOneToOneInverseSide()
     {
-        $train = new Train();
-        $driver = new TrainDriver("Benjamin");
-        $train->setDriver($driver);
+        $owner = new TrainOwner("Alexander");
+        $train = new Train($owner);
 
         $this->_em->persist($train); // cascades
         $this->_em->flush();
@@ -75,9 +75,9 @@ class OneToOneEagerLoadingTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $sqlCount = count($this->_sqlLoggerStack->queries);
 
-        $driver = $this->_em->find(get_class($driver), $driver->id);
-        $this->assertNotInstanceOf('Doctrine\ORM\Proxy\Proxy', $driver->train);
-        $this->assertNotNull($driver->train);
+        $driver = $this->_em->find(get_class($owner), $owner->id);
+        $this->assertNotInstanceOf('Doctrine\ORM\Proxy\Proxy', $owner->train);
+        $this->assertNotNull($owner->train);
 
         $this->assertEquals($sqlCount + 1, count($this->_sqlLoggerStack->queries));
     }
@@ -103,7 +103,7 @@ class OneToOneEagerLoadingTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
     public function testEagerLoadManyToOne()
     {
-        $train = new Train();
+        $train = new Train(new TrainOwner("Alexander"));
         $waggon = new Waggon();
         $train->addWaggon($waggon);
 
@@ -115,6 +115,59 @@ class OneToOneEagerLoadingTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertNotInstanceOf('Doctrine\ORM\Proxy\Proxy', $waggon->train);
         $this->assertNotNull($waggon->train);
     }
+
+    public function testEagerLoadWithNullableColumnsGeneratesLeftJoinOnBothSides()
+    {
+        $train = new Train(new TrainOwner("Alexander"));
+        $driver = new TrainDriver("Benjamin");
+        $train->setDriver($driver);
+
+        $this->_em->persist($train);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $train = $this->_em->find(get_class($train), $train->id);
+        $this->assertEquals(
+            "SELECT t0.id AS id1, t0.driver_id AS driver_id2, t3.id AS id4, t3.name AS name5, t0.owner_id AS owner_id6, t7.id AS id8, t7.name AS name9 FROM Train t0 LEFT JOIN TrainDriver t3 ON t0.driver_id = t3.id INNER JOIN TrainOwner t7 ON t0.owner_id = t7.id WHERE t0.id = ?",
+            $this->_sqlLoggerStack->queries[$this->_sqlLoggerStack->currentQuery]['sql']
+        );
+
+        $this->_em->clear();
+        $driver = $this->_em->find(get_class($driver), $driver->id);
+        $this->assertEquals(
+            "SELECT t0.id AS id1, t0.name AS name2, t3.id AS id4, t3.driver_id AS driver_id5, t3.owner_id AS owner_id6 FROM TrainOwner t0 LEFT JOIN Train t3 ON t3.owner_id = t0.id WHERE t0.id IN (?)",
+            $this->_sqlLoggerStack->queries[$this->_sqlLoggerStack->currentQuery]['sql']
+        );
+    }
+
+    public function testEagerLoadWithNonNullableColumnsGeneratesInnerJoinOnOwningSide()
+    {
+        $waggon = new Waggon();
+        $this->_em->persist($waggon);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $waggon = $this->_em->find(get_class($waggon), $waggon->id);
+        $this->assertEquals(
+            "SELECT t0.id AS id1, t0.train_id AS train_id2, t3.id AS id4, t3.driver_id AS driver_id5, t3.owner_id AS owner_id6 FROM Waggon t0 INNER JOIN Train t3 ON t0.train_id = t3.id WHERE t0.id = ?",
+            $this->_sqlLoggerStack->queries[$this->_sqlLoggerStack->currentQuery]['sql']
+        );
+    }
+
+    public function testEagerLoadWithNonNullableColumnsGeneratesLeftJoinOnNonOwningSide()
+    {
+        $owner = new TrainOwner('Alexander');
+        $train = new Train($owner);
+        $this->_em->persist($train);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $waggon = $this->_em->find(get_class($owner), $owner->id);
+        $this->assertEquals(
+            "SELECT t0.id AS id1, t0.name AS name2, t3.id AS id4, t3.driver_id AS driver_id5, t3.owner_id AS owner_id6 FROM TrainOwner t0 LEFT JOIN Train t3 ON t3.owner_id = t0.id WHERE t0.id = ?",
+            $this->_sqlLoggerStack->queries[$this->_sqlLoggerStack->currentQuery]['sql']
+        );
+    }
 }
 
 /**
@@ -130,16 +183,23 @@ class Train
     /**
      * Owning side
      * @OneToOne(targetEntity="TrainDriver", inversedBy="train", fetch="EAGER", cascade={"persist"})
+     * @JoinColumn(nullable=true)
      */
     public $driver;
+    /**
+     * Owning side
+     * @OneToOne(targetEntity="TrainOwner", inversedBy="train", fetch="EAGER", cascade={"persist"})
+     */
+    public $owner;
     /**
      * @oneToMany(targetEntity="Waggon", mappedBy="train", cascade={"persist"})
      */
     public $waggons;
 
-    public function __construct()
+    public function __construct(TrainOwner $owner)
     {
         $this->waggons = new \Doctrine\Common\Collections\ArrayCollection();
+        $this->setOwner($owner);
     }
 
     public function setDriver(TrainDriver $driver)
@@ -148,6 +208,12 @@ class Train
         $driver->setTrain($this);
     }
 
+    public function setOwner(TrainOwner $owner)
+    {
+        $this->owner = $owner;
+        $owner->setTrain($this);
+    }
+
     public function addWaggon(Waggon $w)
     {
         $w->setTrain($this);
@@ -181,6 +247,32 @@ class TrainDriver
     }
 }
 
+/**
+ * @Entity
+ */
+class TrainOwner
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+    /** @column(type="string") */
+    public $name;
+    /**
+     * Inverse side
+     * @OneToOne(targetEntity="Train", mappedBy="owner", fetch="EAGER")
+     */
+    public $train;
+
+    public function __construct($name)
+    {
+        $this->name = $name;
+    }
+
+    public function setTrain(Train $t)
+    {
+        $this->train = $t;
+    }
+}
+
 /**
  * @Entity
  */
@@ -195,4 +287,4 @@ class Waggon
     {
         $this->train = $train;
     }
-}
+}

tests/Doctrine/Tests/ORM/Functional/PersistentObjectTest.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace Doctrine\Tests\ORM\Functional;
+
+use Doctrine\Common\Persistence\PersistentObject;
+
+/**
+ * Test that Doctrine ORM correctly works with the ObjectManagerAware and PersistentObject
+ * classes from Common.
+ *
+ * @group DDC-1448
+ */
+class PersistentObjectTest extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    protected function setUp()
+    {
+        parent::setUp();
+        try {
+            $this->_schemaTool->createSchema(array(
+                $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\PersistentEntity'),
+            ));
+        } catch (\Exception $e) {
+
+        }
+        PersistentObject::setObjectManager($this->_em);
+    }
+
+    public function testPersist()
+    {
+        $entity = new PersistentEntity();
+        $entity->setName("test");
+
+        $this->_em->persist($entity);
+        $this->_em->flush();
+    }
+
+    public function testFind()
+    {
+        $entity = new PersistentEntity();
+        $entity->setName("test");
+
+        $this->_em->persist($entity);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $entity = $this->_em->find(__NAMESPACE__ . '\PersistentEntity', $entity->getId());
+
+        $this->assertEquals('test', $entity->getName());
+        $entity->setName('foobar');
+
+        $this->_em->flush();
+    }
+
+    public function testGetReference()
+    {
+        $entity = new PersistentEntity();
+        $entity->setName("test");
+
+        $this->_em->persist($entity);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $entity = $this->_em->getReference(__NAMESPACE__ . '\PersistentEntity', $entity->getId());
+
+        $this->assertEquals('test', $entity->getName());
+    }
+
+    public function testSetAssociation()
+    {
+        $entity = new PersistentEntity();
+        $entity->setName("test");
+        $entity->setParent($entity);
+
+        $this->_em->persist($entity);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $entity = $this->_em->getReference(__NAMESPACE__ . '\PersistentEntity', $entity->getId());
+        $this->assertSame($entity, $entity->getParent());
+    }
+}
+
+/**
+ * @Entity
+ */
+class PersistentEntity extends PersistentObject
+{
+    /**
+     * @Id @Column(type="integer") @GeneratedValue
+     * @var int
+     */
+    protected $id;
+
+    /**
+     * @Column(type="string")
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * @ManyToOne(targetEntity="PersistentEntity")
+     * @var PersistentEntity
+     */
+    protected $parent;
+}

tests/Doctrine/Tests/ORM/Functional/PostFlushEventTest.php

@@ -0,0 +1,95 @@
+<?php
+namespace Doctrine\Tests\ORM\Functional;
+use Doctrine\Tests\Models\CMS\CmsUser;
+use Doctrine\ORM\Event\PostFlushEventArgs;
+use Doctrine\ORM\Events;
+require_once __DIR__ . '/../../TestInit.php';
+
+/**
+ * PostFlushEventTest
+ *
+ * @author Daniel Freudenberger <df@rebuy.de>
+ */
+class PostFlushEventTest extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    /**
+     * @var PostFlushListener
+     */
+    private $listener;
+
+    protected function setUp()
+    {
+        $this->useModelSet('cms');
+        parent::setUp();
+        $this->listener = new PostFlushListener();
+        $evm = $this->_em->getEventManager();
+        $evm->addEventListener(Events::postFlush, $this->listener);
+    }
+
+    public function testListenerShouldBeNotified()
+    {
+        $this->_em->persist($this->createNewValidUser());
+        $this->_em->flush();
+        $this->assertTrue($this->listener->wasNotified);
+    }
+
+    public function testListenerShouldNotBeNotifiedWhenFlushThrowsException()
+    {
+        $user = new CmsUser();
+        $user->username = 'dfreudenberger';
+        $this->_em->persist($user);
+        $exceptionRaised = false;
+
+        try {
+            $this->_em->flush();
+        } catch (\Exception $ex) {
+            $exceptionRaised = true;
+        }
+
+        $this->assertTrue($exceptionRaised);
+        $this->assertFalse($this->listener->wasNotified);
+    }
+
+    public function testListenerShouldReceiveEntityManagerThroughArgs()
+    {
+        $this->_em->persist($this->createNewValidUser());
+        $this->_em->flush();
+        $receivedEm = $this->listener->receivedArgs->getEntityManager();
+        $this->assertSame($this->_em, $receivedEm);
+    }
+
+    /**
+     * @return CmsUser
+     */
+    private function createNewValidUser()
+    {
+        $user = new CmsUser();
+        $user->username = 'dfreudenberger';
+        $user->name = 'Daniel Freudenberger';
+        return $user;
+    }
+}
+
+class PostFlushListener
+{
+    /**
+     * @var bool
+     */
+    public $wasNotified = false;
+
+    /**
+     * @var PostFlushEventArgs
+     */
+    public $receivedArgs;
+
+    /**
+     * @param PostFlushEventArgs $args
+     */
+    public function postFlush(PostFlushEventArgs $args)
+    {
+        $this->wasNotified = true;
+        $this->receivedArgs = $args;
+    }
+}
+
+

tests/Doctrine/Tests/ORM/Functional/QueryCacheTest.php

@@ -104,7 +104,7 @@ class QueryCacheTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $query = $this->_em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
         
-        $cache = $this->getMock('Doctrine\Common\Cache\ArrayCache', array('doFetch', 'doSave'));
+        $cache = $this->getMock('Doctrine\Common\Cache\ArrayCache', array('doFetch', 'doSave', 'doGetStats'));
         $cache->expects($this->at(0))
               ->method('doFetch')
               ->with($this->isType('string'))
@@ -135,7 +135,7 @@ class QueryCacheTest extends \Doctrine\Tests\OrmFunctionalTestCase
                          ->will($this->returnValue($sqlExecMock));
 
         $cache = $this->getMock('Doctrine\Common\Cache\CacheProvider', 
-                array('doFetch', 'doContains', 'doSave', 'doDelete', 'doFlush'));
+                array('doFetch', 'doContains', 'doSave', 'doDelete', 'doFlush', 'doGetStats'));
         $cache->expects($this->once())
               ->method('doFetch')
               ->with($this->isType('string'))

tests/Doctrine/Tests/ORM/Functional/QueryTest.php

@@ -34,9 +34,9 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->_em->clear();
 
         $query = $this->_em->createQuery("select u, upper(u.name) from Doctrine\Tests\Models\CMS\CmsUser u where u.username = 'gblanco'");
-        
+
         $result = $query->getResult();
-        
+
         $this->assertEquals(1, count($result));
         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[0][0]);
         $this->assertEquals('Guilherme', $result[0][0]->name);
@@ -109,7 +109,7 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $q = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.username = ?0');
         $q->setParameter(0, 'jwage');
         $user = $q->getSingleResult();
-        
+
         $this->assertNotNull($user);
     }
 
@@ -216,7 +216,7 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
             $identityMap = $this->_em->getUnitOfWork()->getIdentityMap();
             $identityMapCount = count($identityMap['Doctrine\Tests\Models\CMS\CmsArticle']);
             $this->assertTrue($identityMapCount>$iteratedCount);
-            
+
             $iteratedCount++;
         }
 
@@ -235,7 +235,7 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $query = $this->_em->createQuery("SELECT u, a FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN u.articles a");
         $articles = $query->iterate();
     }
-    
+
     /**
      * @expectedException Doctrine\ORM\NoResultException
      */
@@ -366,7 +366,7 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertInstanceOf('Doctrine\ORM\Proxy\Proxy', $result[0]->user);
         $this->assertFalse($result[0]->user->__isInitialized__);
     }
-    
+
     /**
      * @group DDC-952
      */
@@ -386,11 +386,11 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         }
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $articles = $this->_em->createQuery('select a from Doctrine\Tests\Models\CMS\CmsArticle a')
                          ->setFetchMode('Doctrine\Tests\Models\CMS\CmsArticle', 'user', ClassMetadata::FETCH_EAGER)
                          ->getResult();
-        
+
         $this->assertEquals(10, count($articles));
         foreach ($articles AS $article) {
             $this->assertNotInstanceOf('Doctrine\ORM\Proxy\Proxy', $article);
@@ -456,7 +456,43 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $query = $this->_em->createQuery("select u.username from Doctrine\Tests\Models\CMS\CmsUser u where u.username = 'gblanco'");
         $this->assertNull($query->getOneOrNullResult(Query::HYDRATE_SCALAR));
     }
-    
+
+    /**
+     * @group DBAL-171
+     */
+    public function testParameterOrder()
+    {
+        $user1 = new CmsUser;
+        $user1->name = 'Benjamin';
+        $user1->username = 'beberlei';
+        $user1->status = 'developer';
+        $this->_em->persist($user1);
+
+        $user2 = new CmsUser;
+        $user2->name = 'Roman';
+        $user2->username = 'romanb';
+        $user2->status = 'developer';
+        $this->_em->persist($user2);
+
+        $user3 = new CmsUser;
+        $user3->name = 'Jonathan';
+        $user3->username = 'jwage';
+        $user3->status = 'developer';
+        $this->_em->persist($user3);
+
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.status = :a AND u.id IN (:b)");
+        $query->setParameters(array(
+            'b' => array($user1->id, $user2->id, $user3->id),
+            'a' => 'developer',
+        ));
+        $result = $query->getResult();
+
+        $this->assertEquals(3, count($result));
+    }
+
     public function testDqlWithAutoInferOfParameters()
     {
         $user = new CmsUser;
@@ -464,30 +500,30 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $user->username = 'beberlei';
         $user->status = 'developer';
         $this->_em->persist($user);
-        
+
         $user = new CmsUser;
         $user->name = 'Roman';
         $user->username = 'romanb';
         $user->status = 'developer';
         $this->_em->persist($user);
-        
+
         $user = new CmsUser;
         $user->name = 'Jonathan';
         $user->username = 'jwage';
         $user->status = 'developer';
         $this->_em->persist($user);
-        
+
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.username IN (?0)");
         $query->setParameter(0, array('beberlei', 'jwage'));
-        
+
         $users = $query->execute();
-        
+
         $this->assertEquals(2, count($users));
     }
-    
+
     public function testQueryBuilderWithStringWhereClauseContainingOrAndConditionalPrimary()
     {
         $qb = $this->_em->createQueryBuilder();
@@ -495,13 +531,13 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
            ->innerJoin('u.articles', 'a')
            ->where('(u.id = 0) OR (u.id IS NULL)');
-        
+
         $query = $qb->getQuery();
         $users = $query->execute();
-        
+
         $this->assertEquals(0, count($users));
     }
-    
+
     public function testQueryWithArrayOfEntitiesAsParameter()
     {
         $userA = new CmsUser;
@@ -509,31 +545,31 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $userA->username = 'beberlei';
         $userA->status = 'developer';
         $this->_em->persist($userA);
-        
+
         $userB = new CmsUser;
         $userB->name = 'Roman';
         $userB->username = 'romanb';
         $userB->status = 'developer';
         $this->_em->persist($userB);
-        
+
         $userC = new CmsUser;
         $userC->name = 'Jonathan';
         $userC->username = 'jwage';
         $userC->status = 'developer';
         $this->_em->persist($userC);
-        
+
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u IN (?0) OR u.username = ?1");
         $query->setParameter(0, array($userA, $userC));
         $query->setParameter(1, 'beberlei');
-        
+
         $users = $query->execute();
-        
+
         $this->assertEquals(2, count($users));
     }
-    
+
     public function testQueryWithHiddenAsSelectExpression()
     {
         $userA = new CmsUser;
@@ -541,25 +577,25 @@ class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $userA->username = 'beberlei';
         $userA->status = 'developer';
         $this->_em->persist($userA);
-        
+
         $userB = new CmsUser;
         $userB->name = 'Roman';
         $userB->username = 'romanb';
         $userB->status = 'developer';
         $this->_em->persist($userB);
-        
+
         $userC = new CmsUser;
         $userC->name = 'Jonathan';
         $userC->username = 'jwage';
         $userC->status = 'developer';
         $this->_em->persist($userC);
-        
+
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $query = $this->_em->createQuery("SELECT u, (SELECT COUNT(u2.id) FROM Doctrine\Tests\Models\CMS\CmsUser u2) AS HIDDEN total FROM Doctrine\Tests\Models\CMS\CmsUser u");
         $users = $query->execute();
-        
+
         $this->assertEquals(3, count($users));
         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
     }

tests/Doctrine/Tests/ORM/Functional/ReadOnlyTest.php

@@ -27,14 +27,14 @@ class ReadOnlyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->_em->flush();
 
         $readOnly->name = "Test2";
-        $readOnly->number = 4321;
+        $readOnly->numericValue = 4321;
 
         $this->_em->flush();
         $this->_em->clear();
 
         $dbReadOnly = $this->_em->find('Doctrine\Tests\ORM\Functional\ReadOnlyEntity', $readOnly->id);
         $this->assertEquals("Test1", $dbReadOnly->name);
-        $this->assertEquals(1234, $dbReadOnly->number);
+        $this->assertEquals(1234, $dbReadOnly->numericValue);
     }
 }
 
@@ -51,11 +51,11 @@ class ReadOnlyEntity
     /** @column(type="string") */
     public $name;
     /** @Column(type="integer") */
-    public $number;
+    public $numericValue;
 
     public function __construct($name, $number)
     {
         $this->name = $name;
-        $this->number = $number;
+        $this->numericValue = $number;
     }
 }

tests/Doctrine/Tests/ORM/Functional/ReferenceProxyTest.php

@@ -5,6 +5,7 @@ namespace Doctrine\Tests\ORM\Functional;
 use Doctrine\ORM\Proxy\ProxyFactory;
 use Doctrine\ORM\Proxy\ProxyClassGenerator;
 use Doctrine\Tests\Models\ECommerce\ECommerceProduct;
+use Doctrine\Tests\Models\ECommerce\ECommerceShipping;
 
 require_once __DIR__ . '/../../TestInit.php';
 
@@ -97,7 +98,7 @@ class ReferenceProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertTrue($clone->isCloned);
         $this->assertFalse($entity->isCloned);
     }
-    
+
     /**
      * @group DDC-733
      */
@@ -107,12 +108,12 @@ class ReferenceProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         /* @var $entity Doctrine\Tests\Models\ECommerce\ECommerceProduct */
         $entity = $this->_em->getReference('Doctrine\Tests\Models\ECommerce\ECommerceProduct' , $id);
-        
+
         $this->assertFalse($entity->__isInitialized__, "Pre-Condition: Object is unitialized proxy.");
         $this->_em->getUnitOfWork()->initializeObject($entity);
         $this->assertTrue($entity->__isInitialized__, "Should be initialized after called UnitOfWork::initializeObject()");
     }
-    
+
     /**
      * @group DDC-1163
      */
@@ -123,10 +124,10 @@ class ReferenceProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         /* @var $entity Doctrine\Tests\Models\ECommerce\ECommerceProduct */
         $entity = $this->_em->getReference('Doctrine\Tests\Models\ECommerce\ECommerceProduct' , $id);
         $entity->setName('Doctrine 2 Cookbook');
-        
+
         $this->_em->flush();
         $this->_em->clear();
-        
+
         $entity = $this->_em->getReference('Doctrine\Tests\Models\ECommerce\ECommerceProduct' , $id);
         $this->assertEquals('Doctrine 2 Cookbook', $entity->getName());
     }
@@ -160,6 +161,29 @@ class ReferenceProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($entity->__isInitialized__, "Getting the identifier doesn't initialize the proxy.");
     }
 
+    public function testDoNotInitializeProxyOnGettingTheIdentifierAndReturnTheRightType()
+    {
+        $product = new ECommerceProduct();
+        $product->setName('Doctrine Cookbook');
+
+        $shipping = new ECommerceShipping();
+        $shipping->setDays(1);
+        $product->setShipping($shipping);
+        $this->_em->persist($product);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $id = $shipping->getId();
+
+        $product = $this->_em->getRepository('Doctrine\Tests\Models\ECommerce\ECommerceProduct')->find($product->getId());
+
+        $entity = $product->getShipping();
+        $this->assertFalse($entity->__isInitialized__, "Pre-Condition: Object is unitialized proxy.");
+        $this->assertEquals($id, $entity->getId());
+        $this->assertSame($id, $entity->getId(), "Check that the id's are the same value, and type.");
+        $this->assertFalse($entity->__isInitialized__, "Getting the identifier doesn't initialize the proxy.");
+    }
+
     public function testInitializeProxyOnGettingSomethingOtherThanTheIdentifier()
     {
         $id = $this->createProduct();

tests/Doctrine/Tests/ORM/Functional/ResultCacheTest.php

@@ -90,10 +90,10 @@ class ResultCacheTest extends \Doctrine\Tests\OrmFunctionalTestCase
     public function testUseResultCache()
     {
         $cache = new \Doctrine\Common\Cache\ArrayCache();
-        $this->_em->getConfiguration()->setResultCacheImpl($cache);
 
         $query = $this->_em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
         $query->useResultCache(true);
+        $query->setResultCacheDriver($cache);
         $query->setResultCacheId('testing_result_cache_id');
         $users = $query->getResult();
 
@@ -108,11 +108,11 @@ class ResultCacheTest extends \Doctrine\Tests\OrmFunctionalTestCase
     public function testUseResultCacheParams()
     {
         $cache = new \Doctrine\Common\Cache\ArrayCache();
-        $this->_em->getConfiguration()->setResultCacheImpl($cache);
 
         $sqlCount = count($this->_sqlLoggerStack->queries);
         $query = $this->_em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux WHERE ux.id = ?1');
         $query->setParameter(1, 1);
+        $query->setResultCacheDriver($cache);
         $query->useResultCache(true);
         $query->getResult();
 
@@ -149,10 +149,10 @@ class ResultCacheTest extends \Doctrine\Tests\OrmFunctionalTestCase
     }
 
     /**
-     * @param <type> $query
+     * @param string $query
      * @depends testNativeQueryResultCaching
      */
-    public function testResultCacheDependsOnQueryHints($query)
+    public function testResultCacheNotDependsOnQueryHints($query)
     {
         $cache = $query->getResultCacheDriver();
         $cacheCount = $this->getCacheSize($cache);
@@ -160,7 +160,7 @@ class ResultCacheTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $query->setHint('foo', 'bar');
         $query->getResult();
 
-        $this->assertEquals($cacheCount + 1, $this->getCacheSize($cache));
+        $this->assertEquals($cacheCount, $this->getCacheSize($cache));
     }
 
     /**
@@ -182,7 +182,7 @@ class ResultCacheTest extends \Doctrine\Tests\OrmFunctionalTestCase
      * @param <type> $query
      * @depends testNativeQueryResultCaching
      */
-    public function testResultCacheDependsOnHydrationMode($query)
+    public function testResultCacheNotDependsOnHydrationMode($query)
     {
         $cache = $query->getResultCacheDriver();
         $cacheCount = $this->getCacheSize($cache);
@@ -190,7 +190,7 @@ class ResultCacheTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertNotEquals(\Doctrine\ORM\Query::HYDRATE_ARRAY, $query->getHydrationMode());
         $query->getArrayResult();
 
-        $this->assertEquals($cacheCount + 1, $this->getCacheSize($cache));
+        $this->assertEquals($cacheCount, $this->getCacheSize($cache));
     }
 
     /**

tests/Doctrine/Tests/ORM/Functional/SchemaTool/MySqlSchemaToolTest.php

@@ -27,15 +27,16 @@ class MySqlSchemaToolTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $tool = new SchemaTool($this->_em);
         $sql = $tool->getCreateSchemaSql($classes);
         $this->assertEquals("CREATE TABLE cms_addresses (id INT AUTO_INCREMENT NOT NULL, user_id INT DEFAULT NULL, country VARCHAR(50) NOT NULL, zip VARCHAR(50) NOT NULL, city VARCHAR(50) NOT NULL, UNIQUE INDEX UNIQ_ACAC157BA76ED395 (user_id), PRIMARY KEY(id)) ENGINE = InnoDB", $sql[0]);
-        $this->assertEquals("CREATE TABLE cms_users (id INT AUTO_INCREMENT NOT NULL, status VARCHAR(50) NOT NULL, username VARCHAR(255) NOT NULL, name VARCHAR(255) NOT NULL, UNIQUE INDEX UNIQ_3AF03EC5F85E0677 (username), PRIMARY KEY(id)) ENGINE = InnoDB", $sql[1]);
+        $this->assertEquals("CREATE TABLE cms_users (id INT AUTO_INCREMENT NOT NULL, email_id INT DEFAULT NULL, status VARCHAR(50) DEFAULT NULL, username VARCHAR(255) NOT NULL, name VARCHAR(255) NOT NULL, UNIQUE INDEX UNIQ_3AF03EC5F85E0677 (username), UNIQUE INDEX UNIQ_3AF03EC5A832C1C9 (email_id), PRIMARY KEY(id)) ENGINE = InnoDB", $sql[1]);
         $this->assertEquals("CREATE TABLE cms_users_groups (user_id INT NOT NULL, group_id INT NOT NULL, INDEX IDX_7EA9409AA76ED395 (user_id), INDEX IDX_7EA9409AFE54D947 (group_id), PRIMARY KEY(user_id, group_id)) ENGINE = InnoDB", $sql[2]);
         $this->assertEquals("CREATE TABLE cms_phonenumbers (phonenumber VARCHAR(50) NOT NULL, user_id INT DEFAULT NULL, INDEX IDX_F21F790FA76ED395 (user_id), PRIMARY KEY(phonenumber)) ENGINE = InnoDB", $sql[3]);
-        $this->assertEquals("ALTER TABLE cms_addresses ADD FOREIGN KEY (user_id) REFERENCES cms_users(id)", $sql[4]);
-        $this->assertEquals("ALTER TABLE cms_users_groups ADD FOREIGN KEY (user_id) REFERENCES cms_users(id)", $sql[5]);
-        $this->assertEquals("ALTER TABLE cms_users_groups ADD FOREIGN KEY (group_id) REFERENCES cms_groups(id)", $sql[6]);
-        $this->assertEquals("ALTER TABLE cms_phonenumbers ADD FOREIGN KEY (user_id) REFERENCES cms_users(id)", $sql[7]);
-        
-        $this->assertEquals(8, count($sql));
+        $this->assertEquals("ALTER TABLE cms_addresses ADD CONSTRAINT FK_ACAC157BA76ED395 FOREIGN KEY (user_id) REFERENCES cms_users (id)", $sql[4]);
+        $this->assertEquals("ALTER TABLE cms_users ADD CONSTRAINT FK_3AF03EC5A832C1C9 FOREIGN KEY (email_id) REFERENCES cms_emails (id)", $sql[5]);
+        $this->assertEquals("ALTER TABLE cms_users_groups ADD CONSTRAINT FK_7EA9409AA76ED395 FOREIGN KEY (user_id) REFERENCES cms_users (id)", $sql[6]);
+        $this->assertEquals("ALTER TABLE cms_users_groups ADD CONSTRAINT FK_7EA9409AFE54D947 FOREIGN KEY (group_id) REFERENCES cms_groups (id)", $sql[7]);
+        $this->assertEquals("ALTER TABLE cms_phonenumbers ADD CONSTRAINT FK_F21F790FA76ED395 FOREIGN KEY (user_id) REFERENCES cms_users (id)", $sql[8]);
+
+        $this->assertEquals(9, count($sql));
     }
     
     public function testGetCreateSchemaSql2()
@@ -63,4 +64,4 @@ class MySqlSchemaToolTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertEquals(1, count($sql));
         $this->assertEquals("CREATE TABLE boolean_model (id INT AUTO_INCREMENT NOT NULL, booleanField TINYINT(1) NOT NULL, PRIMARY KEY(id)) ENGINE = InnoDB", $sql[0]);
     }
-}
+}