Fix wrong version

"Basic Mapping" documentation says:
"decimal: Type that maps a SQL DECIMAL to a PHP string."

UPGRADE.md

@@ -1,5 +1,11 @@
 # Upgrade to 2.3
 
+## Auto Discriminator Map breaks userland implementations with Listener
+
+The new feature to detect discriminator maps automatically when none
+are provided breaks userland implementations doing this with a
+listener in ``loadClassMetadata`` event.
+
 ## EntityManager#find() not calls EntityRepository#find() anymore
 
 Previous to 2.3, calling ``EntityManager#find()`` would be delegated to

composer.json

@@ -1,6 +1,6 @@
 {
     "name": "doctrine/orm",
-    "type": "library","version":"2.3.4",
+    "type": "library",
     "description": "Object-Relational-Mapper for PHP",
     "keywords": ["orm", "database"],
     "homepage": "http://www.doctrine-project.org",

lib/Doctrine/ORM/AbstractQuery.php

@@ -662,6 +662,18 @@ abstract class AbstractQuery
         return isset($this->_hints[$name]) ? $this->_hints[$name] : false;
     }
 
+    /**
+     * Check if the query has a hint
+     *
+     * @param  string $name The name of the hint
+     *
+     * @return bool False if the query does not have any hint
+     */
+    public function hasHint($name)
+    {
+        return isset($this->_hints[$name]);
+    }
+
     /**
      * Return the key value map of query hints that are currently set.
      *

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

@@ -118,6 +118,7 @@ class ArrayHydrator extends AbstractHydrator
                     $baseElement =& $this->_resultPointers[$parent];
                 } else {
                     unset($this->_resultPointers[$dqlAlias]); // Ticket #1228
+
                     continue;
                 }
 
@@ -139,6 +140,7 @@ class ArrayHydrator extends AbstractHydrator
 
                         if ( ! $indexExists || ! $indexIsValid) {
                             $element = $data;
+
                             if (isset($this->_rsm->indexByMap[$dqlAlias])) {
                                 $baseElement[$relationAlias][$row[$this->_rsm->indexByMap[$dqlAlias]]] = $element;
                             } else {
@@ -155,7 +157,10 @@ class ArrayHydrator extends AbstractHydrator
                 } else {
                     $oneToOne = true;
 
-                    if ( ! isset($nonemptyComponents[$dqlAlias]) && ! isset($baseElement[$relationAlias])) {
+                    if (
+                        ( ! isset($nonemptyComponents[$dqlAlias])) &&
+                        ( ! isset($baseElement[$relationAlias]))
+                    ) {
                         $baseElement[$relationAlias] = null;
                     } else if ( ! isset($baseElement[$relationAlias])) {
                         $baseElement[$relationAlias] = $data;
@@ -164,10 +169,9 @@ class ArrayHydrator extends AbstractHydrator
 
                 $coll =& $baseElement[$relationAlias];
 
-                if ($coll !== null) {
+                if (is_array($coll)) {
                     $this->updateResultPointer($coll, $index, $dqlAlias, $oneToOne);
                 }
-
             } else {
                 // It's a root result element
 
@@ -176,22 +180,21 @@ class ArrayHydrator extends AbstractHydrator
 
                 // 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($entityKey => null);
-                    } else {
-                        $result[] = null;
-                    }
+                    $result[] = $this->_rsm->isMixed
+                        ? array($entityKey => null)
+                        : 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 ($this->_rsm->isMixed) {
-                        $element = array($entityKey => $element);
-                    }
+                    $element = $this->_rsm->isMixed
+                        ? array($entityKey => $rowData[$dqlAlias])
+                        : $rowData[$dqlAlias];
 
                     if (isset($this->_rsm->indexByMap[$dqlAlias])) {
                         $resultKey = $row[$this->_rsm->indexByMap[$dqlAlias]];
@@ -199,6 +202,7 @@ class ArrayHydrator extends AbstractHydrator
                     } else {
                         $resultKey = $this->_resultCounter;
                         $result[] = $element;
+
                         ++$this->_resultCounter;
                     }
 
@@ -206,11 +210,13 @@ class ArrayHydrator extends AbstractHydrator
                 } else {
                     $index = $this->_identifierMap[$dqlAlias][$id[$dqlAlias]];
                     $resultKey = $index;
+
                     /*if ($this->_rsm->isMixed) {
                         $result[] =& $result[$index];
                         ++$this->_resultCounter;
                     }*/
                 }
+
                 $this->updateResultPointer($result, $index, $dqlAlias, false);
             }
         }
@@ -219,11 +225,9 @@ class ArrayHydrator extends AbstractHydrator
         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;
-                }
+                $resultKey = isset($this->_rsm->indexByMap['scalars'])
+                    ? $row[$this->_rsm->indexByMap['scalars']]
+                    : $this->_resultCounter - 1;
             }
 
             foreach ($scalars as $name => $value) {
@@ -249,6 +253,12 @@ class ArrayHydrator extends AbstractHydrator
             return;
         }
 
+        if ($oneToOne) {
+            $this->_resultPointers[$dqlAlias] =& $coll;
+
+            return;
+        }
+
         if ($index !== false) {
             $this->_resultPointers[$dqlAlias] =& $coll[$index];
 
@@ -259,12 +269,6 @@ class ArrayHydrator extends AbstractHydrator
             return;
         }
 
-        if ($oneToOne) {
-            $this->_resultPointers[$dqlAlias] =& $coll;
-
-            return;
-        }
-
         end($coll);
         $this->_resultPointers[$dqlAlias] =& $coll[key($coll)];
 

lib/Doctrine/ORM/Mapping/ClassMetadataInfo.php

@@ -827,7 +827,11 @@ class ClassMetadataInfo implements ClassMetadata
     public function newInstance()
     {
         if ($this->_prototype === null) {
-            $this->_prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($this->name), $this->name));
+            if (PHP_VERSION_ID === 50429 || PHP_VERSION_ID === 50513) {
+                $this->_prototype = $this->reflClass->newInstanceWithoutConstructor();
+            } else {
+                $this->_prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($this->name), $this->name));
+            }
         }
 
         return clone $this->_prototype;
@@ -2606,8 +2610,12 @@ class ClassMetadataInfo implements ClassMetadata
      */
     public function setSequenceGeneratorDefinition(array $definition)
     {
-        if (isset($definition['name']) && $definition['name'] == '`') {
-            $definition['name']   = trim($definition['name'], '`');
+        if ( ! isset($definition['sequenceName'])) {
+            throw MappingException::missingSequenceName($this->name);
+        }
+
+        if ($definition['sequenceName'][0] == '`') {
+            $definition['sequenceName']   = trim($definition['sequenceName'], '`');
             $definition['quoted'] = true;
         }
 

lib/Doctrine/ORM/Mapping/MappingException.php

@@ -438,4 +438,16 @@ class MappingException extends \Doctrine\ORM\ORMException
             $cascades
         ));
     }
+
+    /**
+     * @param string $className
+     *
+     * @return MappingException
+     */
+    public static function missingSequenceName($className)
+    {
+        return new self(
+            sprintf('Missing "sequenceName" attribute for sequence id generator definition on class "%s".', $className)
+        );
+    }
 }

lib/Doctrine/ORM/OptimisticLockException.php

@@ -54,6 +54,8 @@ class OptimisticLockException extends ORMException
 
     public static function lockFailedVersionMissmatch($entity, $expectedLockVersion, $actualLockVersion)
     {
+        $expectedLockVersion = ($expectedLockVersion instanceof \DateTime) ? $expectedLockVersion->getTimestamp() : $expectedLockVersion;
+        $actualLockVersion = ($actualLockVersion instanceof \DateTime) ? $actualLockVersion->getTimestamp() : $actualLockVersion;
         return new self("The optimistic lock failed, version " . $expectedLockVersion . " was expected, but is actually ".$actualLockVersion, $entity);
     }
 

lib/Doctrine/ORM/PersistentCollection.php

@@ -717,6 +717,8 @@ final class PersistentCollection implements Collection, Selectable
 
     public function key()
     {
+        $this->initialize();
+
         return $this->coll->key();
     }
 
@@ -725,6 +727,8 @@ final class PersistentCollection implements Collection, Selectable
      */
     public function current()
     {
+        $this->initialize();
+
         return $this->coll->current();
     }
 
@@ -733,6 +737,8 @@ final class PersistentCollection implements Collection, Selectable
      */
     public function next()
     {
+        $this->initialize();
+        
         return $this->coll->next();
     }
 

lib/Doctrine/ORM/Persisters/BasicEntityPersister.php

@@ -88,7 +88,7 @@ class BasicEntityPersister
      */
     static private $comparisonMap = array(
         Comparison::EQ  => '= %s',
-        Comparison::IS  => 'IS %s',
+        Comparison::IS  => '= %s',
         Comparison::NEQ => '!= %s',
         Comparison::GT  => '> %s',
         Comparison::GTE => '>= %s',
@@ -518,13 +518,34 @@ class BasicEntityPersister
      */
     public function delete($entity)
     {
+        $class      = $this->_class;
+        $em         = $this->_em;
+
         $identifier = $this->_em->getUnitOfWork()->getEntityIdentifier($entity);
+        $tableName  = $this->quoteStrategy->getTableName($class, $this->_platform);
+        $idColumns  = $this->quoteStrategy->getIdentifierColumnNames($class, $this->_platform);
+        $id         = array_combine($idColumns, $identifier);
+        $types      = array_map(function ($identifier) use ($class, $em) {
+
+            if (isset($class->fieldMappings[$identifier])) {
+                return $class->fieldMappings[$identifier]['type'];
+            }
+
+            $targetMapping = $em->getClassMetadata($class->associationMappings[$identifier]['targetEntity']);
+
+            if (isset($targetMapping->fieldMappings[$targetMapping->identifier[0]])) {
+                return $targetMapping->fieldMappings[$targetMapping->identifier[0]]['type'];
+            }
+
+            if (isset($targetMapping->associationMappings[$targetMapping->identifier[0]])) {
+                return $targetMapping->associationMappings[$targetMapping->identifier[0]]['type'];
+            }
+
+            throw ORMException::unrecognizedField($targetMapping->identifier[0]);
+        }, $class->identifier);
 
         $this->deleteJoinTableRecords($identifier);
-
-        $id = array_combine($this->quoteStrategy->getIdentifierColumnNames($this->_class, $this->_platform), $identifier);
-
-        $this->_conn->delete($this->quoteStrategy->getTableName($this->_class, $this->_platform), $id);
+        $this->_conn->delete($tableName, $id, $types);
     }
 
     /**
@@ -1457,6 +1478,18 @@ class BasicEntityPersister
             $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->_platform);
         }
 
+        if ($comparison !== null) {
+
+            // special case null value handling
+            if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
+                return $conditionSql . ' IS NULL';
+            } else if ($comparison === Comparison::NEQ && $value === null) {
+                return $conditionSql . ' IS NOT NULL';
+            }
+
+            return $conditionSql . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
+        }
+
         $conditionSql .= ($comparison === null)
             ? ((is_array($value)) ? ' IN (?)' : (($value === null) ? ' IS NULL' : ' = ' . $placeholder))
             : ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);

lib/Doctrine/ORM/Persisters/JoinedSubclassPersister.php

@@ -184,7 +184,9 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
                 }
 
                 foreach ($data as $columnName => $value) {
-                    $stmt->bindValue($paramIndex++, $value, $this->_columnTypes[$columnName]);
+                    if (!is_array($id) || !isset($id[$columnName])) {
+                        $stmt->bindValue($paramIndex++, $value, $this->_columnTypes[$columnName]);
+                    }
                 }
 
                 $stmt->execute();

lib/Doctrine/ORM/Persisters/SqlValueVisitor.php

@@ -57,7 +57,14 @@ class SqlValueVisitor extends ExpressionVisitor
     {
         $value          = $comparison->getValue()->getValue();
         $field          = $comparison->getField();
-        
+        $operator       = $comparison->getOperator();
+
+        if (($operator === Comparison::EQ || $operator === Comparison::IS) && $value === null) {
+            return;
+        } else if ($operator === Comparison::NEQ && $value === null) {
+            return;
+        }
+
         $this->values[] = $value;
         $this->types[]  = array($field, $value);
     }

lib/Doctrine/ORM/Query/ResultSetMappingBuilder.php

@@ -101,7 +101,13 @@ class ResultSetMappingBuilder extends ResultSetMapping
                     if (isset($this->metaMappings[$renamedColumnName])) {
                         throw new \InvalidArgumentException("The column '$renamedColumnName' conflicts with another column in the mapper.");
                     }
-                    $this->addMetaResult($alias, $renamedColumnName, $columnName);
+
+                    $this->addMetaResult(
+                        $alias,
+                        $renamedColumnName,
+                        $columnName,
+                        (isset($associationMapping['id']) && $associationMapping['id'] === true)
+                    );
                 }
             }
         }

lib/Doctrine/ORM/Query/SqlWalker.php

@@ -804,9 +804,13 @@ class SqlWalker implements TreeWalker
     /**
      * Walks down a JoinAssociationDeclaration AST node, thereby generating the appropriate SQL.
      *
+     * @param AST\JoinAssociationDeclaration $joinAssociationDeclaration
+     * @param int                            $joinType
+     * @param AST\ConditionalExpression      $condExpr
+     *
      * @return string
      */
-    public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER)
+    public function walkJoinAssociationDeclaration($joinAssociationDeclaration, $joinType = AST\Join::JOIN_TYPE_INNER, $condExpr = null)
     {
         $sql = '';
 
@@ -921,6 +925,13 @@ class SqlWalker implements TreeWalker
                 break;
         }
 
+        // Handle WITH clause
+        if ($condExpr !== null) {
+            // Phase 2 AST optimization: Skip processing of ConditionalExpression
+            // if only one ConditionalTerm is defined
+            $sql .= ' AND (' . $this->walkConditionalExpression($condExpr) . ')';
+        }
+
         // FIXME: these should either be nested or all forced to be left joins (DDC-XXX)
         if ($targetClass->isInheritanceTypeJoined()) {
             $sql .= $this->_generateClassTableInheritanceJoins($targetClass, $joinedDqlAlias);
@@ -1020,14 +1031,7 @@ class SqlWalker implements TreeWalker
                 break;
 
             case ($joinDeclaration instanceof \Doctrine\ORM\Query\AST\JoinAssociationDeclaration):
-                $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType);
-
-                // Handle WITH clause
-                if (($condExpr = $join->conditionalExpression) !== null) {
-                    // Phase 2 AST optimization: Skip processment of ConditionalExpression
-                    // if only one ConditionalTerm is defined
-                    $sql .= ' AND (' . $this->walkConditionalExpression($condExpr) . ')';
-                }
+                $sql .= $this->walkJoinAssociationDeclaration($joinDeclaration, $joinType, $join->conditionalExpression);
                 break;
         }
 

lib/Doctrine/ORM/Tools/EntityGenerator.php

@@ -152,7 +152,7 @@ class EntityGenerator
         Type::SMALLINT      => 'integer',
         Type::TEXT          => 'string',
         Type::BLOB          => 'string',
-        Type::DECIMAL       => 'float',
+        Type::DECIMAL       => 'string',
         Type::JSON_ARRAY    => 'array',
         Type::SIMPLE_ARRAY  => 'array',
     );

lib/Doctrine/ORM/Tools/Pagination/Paginator.php

@@ -122,7 +122,7 @@ class Paginator implements \Countable, \IteratorAggregate
             /* @var $countQuery Query */
             $countQuery = $this->cloneQuery($this->query);
 
-            if ( ! $countQuery->getHint(CountWalker::HINT_DISTINCT)) {
+            if ( ! $countQuery->hasHint(CountWalker::HINT_DISTINCT)) {
                 $countQuery->setHint(CountWalker::HINT_DISTINCT, true);
             }
 

lib/Doctrine/ORM/UnitOfWork.php

@@ -2318,6 +2318,7 @@ class UnitOfWork implements PropertyChangedListener
             $this->collectionUpdates =
             $this->extraUpdates =
             $this->readOnlyObjects =
+            $this->visitedCollections =
             $this->orphanRemovals = array();
 
             if ($this->commitOrderCalculator !== null) {
@@ -2425,15 +2426,15 @@ class UnitOfWork implements PropertyChangedListener
                     ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
                     : $data[$fieldName];
             }
-
-            $idHash = implode(' ', $id);
         } else {
-            $idHash = isset($class->associationMappings[$class->identifier[0]])
+            $id = isset($class->associationMappings[$class->identifier[0]])
                 ? $data[$class->associationMappings[$class->identifier[0]]['joinColumns'][0]['name']]
                 : $data[$class->identifier[0]];
 
-            $id = array($class->identifier[0] => $idHash);
+            $id = array($class->identifier[0] => $id);
         }
+        
+        $idHash = implode(' ', $id);
 
         if (isset($this->identityMap[$class->rootEntityName][$idHash])) {
             $entity = $this->identityMap[$class->rootEntityName][$idHash];
@@ -2708,6 +2709,8 @@ class UnitOfWork implements PropertyChangedListener
                 $persister->loadManyToManyCollection($assoc, $collection->getOwner(), $collection);
                 break;
         }
+
+        $collection->setInitialized(true);
     }
 
     /**

lib/Doctrine/ORM/Version.php

@@ -36,7 +36,7 @@ class Version
     /**
      * Current Doctrine Version
      */
-    const VERSION = '2.3.4';
+    const VERSION = '2.3.6-DEV';
 
     /**
      * Compares a Doctrine version with the current one.

tests/Doctrine/Tests/Models/Taxi/Car.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Doctrine\Tests\Models\Taxi;
+
+/**
+ * @Entity
+ * @Table(name="taxi_car")
+ */
+class Car
+{
+    /**
+     * @Id
+     * @Column(type="string", length=25)
+     * @GeneratedValue(strategy="NONE")
+     */
+    private $brand;
+
+    /**
+     * @Column(type="string", length=255);
+     */
+    private $model;
+
+    /**
+     * @OneToMany(targetEntity="Ride", mappedBy="car")
+     */
+    private $freeCarRides;
+
+    /**
+     * @OneToMany(targetEntity="PaidRide", mappedBy="car")
+     */
+    private $carRides;
+
+    public function setBrand($brand)
+    {
+        $this->brand = $brand;
+    }
+
+    public function setModel($model)
+    {
+        $this->model = $model;
+    }
+}

tests/Doctrine/Tests/Models/Taxi/Driver.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Doctrine\Tests\Models\Taxi;
+
+/**
+ * @Entity
+ * @Table(name="taxi_driver")
+ */
+class Driver
+{
+    /**
+     * @Id
+     * @Column(type="integer")
+     * @GeneratedValue(strategy="AUTO")
+     */
+    private $id;
+
+    /**
+     * @Column(type="string", length=255);
+     */
+    private $name;
+
+    /**
+     * @OneToMany(targetEntity="Ride", mappedBy="driver")
+     */
+    private $freeDriverRides;
+
+    /**
+     * @OneToMany(targetEntity="PaidRide", mappedBy="driver")
+     */
+    private $driverRides;
+
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+}

tests/Doctrine/Tests/Models/Taxi/PaidRide.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Doctrine\Tests\Models\Taxi;
+
+/**
+ * Same as Ride but with an extra column that is not part of the composite primary key
+ *
+ * @Entity
+ * @Table(name="taxi_paid_ride")
+ */
+class PaidRide
+{
+    /**
+     * @Id
+     * @ManyToOne(targetEntity="Driver", inversedBy="driverRides")
+     * @JoinColumn(name="driver_id", referencedColumnName="id")
+     */
+    private $driver;
+
+    /**
+     * @Id
+     * @ManyToOne(targetEntity="Car", inversedBy="carRides")
+     * @JoinColumn(name="car", referencedColumnName="brand")
+     */
+    private $car;
+
+    /**
+     * @Column(type="decimal", precision=6, scale=2)
+     */
+    private $fare;
+
+    public function __construct(Driver $driver, Car $car)
+    {
+        $this->driver = $driver;
+        $this->car = $car;
+    }
+
+    public function setFare($fare)
+    {
+        $this->fare = $fare;
+    }
+}

tests/Doctrine/Tests/Models/Taxi/Ride.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Doctrine\Tests\Models\Taxi;
+
+/**
+ * Test model that contains only Id-columns
+ *
+ * @Entity
+ * @Table(name="taxi_ride")
+ */
+class Ride
+{
+    /**
+     * @Id
+     * @ManyToOne(targetEntity="Driver", inversedBy="freeDriverRides")
+     * @JoinColumn(name="driver_id", referencedColumnName="id")
+     */
+    private $driver;
+
+    /**
+     * @Id
+     * @ManyToOne(targetEntity="Car", inversedBy="freeCarRides")
+     * @JoinColumn(name="car", referencedColumnName="brand")
+     */
+    private $car;
+
+    public function __construct(Driver $driver, Car $car)
+    {
+        $this->driver = $driver;
+        $this->car = $car;
+    }
+}

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

@@ -84,4 +84,60 @@ class EntityRepositoryCriteriaTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $this->assertEquals(2, count($dates));
     }
+
+    private function loadNullFieldFixtures()
+    {
+        $today = new DateTimeModel();
+        $today->datetime =
+        $today->date =
+            new \DateTime('today');
+
+        $this->_em->persist($today);
+
+        $tomorrow = new DateTimeModel();
+        $tomorrow->datetime =
+        $tomorrow->date =
+        $tomorrow->time =
+            new \DateTime('tomorrow');
+        $this->_em->persist($tomorrow);
+
+        $this->_em->flush();
+        $this->_em->clear();
+    }
+
+    public function testIsNullComparison()
+    {
+        $this->loadNullFieldFixtures();
+        $repository = $this->_em->getRepository('Doctrine\Tests\Models\Generic\DateTimeModel');
+
+        $dates = $repository->matching(new Criteria(
+            Criteria::expr()->isNull('time')
+        ));
+
+        $this->assertEquals(1, count($dates));
+    }
+
+    public function testEqNullComparison()
+    {
+        $this->loadNullFieldFixtures();
+        $repository = $this->_em->getRepository('Doctrine\Tests\Models\Generic\DateTimeModel');
+
+        $dates = $repository->matching(new Criteria(
+            Criteria::expr()->eq('time', null)
+        ));
+
+        $this->assertEquals(1, count($dates));
+    }
+
+    public function testNotEqNullComparison()
+    {
+        $this->loadNullFieldFixtures();
+        $repository = $this->_em->getRepository('Doctrine\Tests\Models\Generic\DateTimeModel');
+
+        $dates = $repository->matching(new Criteria(
+            Criteria::expr()->neq('time', null)
+        ));
+
+        $this->assertEquals(1, count($dates));
+    }
 }

tests/Doctrine/Tests/ORM/Functional/Locking/OptimisticTest.php

@@ -7,6 +7,8 @@ use Doctrine\ORM\OptimisticLockException;
 use Doctrine\Common\EventManager;
 use Doctrine\ORM\Mapping\ClassMetadataFactory;
 use Doctrine\Tests\TestUtil;
+use Doctrine\DBAL\LockMode;
+use DateTime;
 
 require_once __DIR__ . '/../../../TestInit.php';
 
@@ -181,13 +183,44 @@ class OptimisticTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->_conn->executeQuery('UPDATE optimistic_timestamp SET version = ? WHERE id = ?', array(date($format, strtotime($test->version->format($format)) + 3600), $test->id));
 
         // Try and update the record and it should throw an exception
+        $caughtException = null;
         $test->name = 'Testing again';
         try {
             $this->_em->flush();
         } catch (OptimisticLockException $e) {
-            $this->assertSame($test, $e->getEntity());
+            $caughtException = $e;
         }
+
+        $this->assertNotNull($caughtException, "No OptimisticLockingException was thrown");
+        $this->assertSame($test, $caughtException->getEntity());
+
     }
+
+    /**
+     * @depends testOptimisticTimestampSetsDefaultValue
+     */
+    public function testOptimisticTimestampLockFailureThrowsException(OptimisticTimestamp $entity)
+    {
+        $q = $this->_em->createQuery('SELECT t FROM Doctrine\Tests\ORM\Functional\Locking\OptimisticTimestamp t WHERE t.id = :id');
+        $q->setParameter('id', $entity->id);
+        $test = $q->getSingleResult();
+
+        $this->assertInstanceOf('DateTime', $test->version);
+
+        // Try to lock the record with an older timestamp and it should throw an exception
+        $caughtException = null;
+        try {
+            $expectedVersionExpired = DateTime::createFromFormat('U', $test->version->getTimestamp()-3600);
+            $this->_em->lock($test, LockMode::OPTIMISTIC, $expectedVersionExpired);
+        } catch (OptimisticLockException $e) {
+            $caughtException = $e;
+        }
+
+        $this->assertNotNull($caughtException, "No OptimisticLockingException was thrown");
+        $this->assertSame($test, $caughtException->getEntity());
+
+    }
+
 }
 
 /**

tests/Doctrine/Tests/ORM/Functional/Ticket/DDC1884Test.php

@@ -0,0 +1,158 @@
+<?php
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\Tests\Models\Taxi\Car,
+    Doctrine\Tests\Models\Taxi\Driver,
+    Doctrine\Tests\Models\Taxi\Ride,
+    Doctrine\Tests\Models\Taxi\PaidRide;
+
+require_once __DIR__ . '/../../../TestInit.php';
+
+/**
+ * @group DDC-1884
+ * @author Sander Coolen <sander@jibber.nl>
+ */
+class DDC1884Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    protected function setUp()
+    {
+        $this->useModelSet('taxi');
+        parent::setUp();
+
+        list($bimmer, $crysler, $merc, $volvo) = $this->createCars('Doctrine\Tests\Models\Taxi\Car');
+        list($john, $foo) = $this->createDrivers('Doctrine\Tests\Models\Taxi\Driver');
+        $this->_em->flush();
+
+        $ride1 = new Ride($john, $bimmer);
+        $ride2 = new Ride($john, $merc);
+        $ride3 = new Ride($john, $volvo);
+        $ride4 = new Ride($foo, $merc);
+
+        $this->_em->persist($ride1);
+        $this->_em->persist($ride2);
+        $this->_em->persist($ride3);
+        $this->_em->persist($ride4);
+
+        $ride5 = new PaidRide($john, $bimmer);
+        $ride5->setFare(10.50);
+
+        $ride6 = new PaidRide($john, $merc);
+        $ride6->setFare(16.00);
+
+        $ride7 = new PaidRide($john, $volvo);
+        $ride7->setFare(20.70);
+
+        $ride8 = new PaidRide($foo, $merc);
+        $ride8->setFare(32.15);
+
+        $this->_em->persist($ride5);
+        $this->_em->persist($ride6);
+        $this->_em->persist($ride7);
+        $this->_em->persist($ride8);
+
+        $this->_em->flush();
+    }
+
+    private function createCars($class)
+    {
+        $bimmer = new $class;
+        $bimmer->setBrand('BMW');
+        $bimmer->setModel('7-Series');
+
+        $crysler = new $class;
+        $crysler->setBrand('Crysler');
+        $crysler->setModel('300');
+
+        $merc = new $class;
+        $merc->setBrand('Mercedes');
+        $merc->setModel('C-Class');
+
+        $volvo = new $class;
+        $volvo->setBrand('Volvo');
+        $volvo->setModel('XC90');
+
+        $this->_em->persist($bimmer);
+        $this->_em->persist($crysler);
+        $this->_em->persist($merc);
+        $this->_em->persist($volvo);
+
+        return array($bimmer, $crysler, $merc, $volvo);
+    }
+
+    private function createDrivers($class)
+    {
+        $john = new $class;
+        $john->setName('John Doe');
+
+        $foo = new $class;
+        $foo->setName('Foo Bar');
+
+        $this->_em->persist($foo);
+        $this->_em->persist($john);
+
+        return array($john, $foo);
+    }
+
+    /**
+     * 1) Ride contains only columns that are part of its composite primary key
+     * 2) We use fetch joins here
+     */
+    public function testSelectFromInverseSideWithCompositePkAndSolelyIdentifierColumnsUsingFetchJoins()
+    {
+        $qb = $this->_em->createQueryBuilder();
+
+        $result = $qb->select('d, dr, c')
+            ->from('Doctrine\Tests\Models\Taxi\Driver', 'd')
+            ->leftJoin('d.freeDriverRides', 'dr')
+            ->leftJoin('dr.car', 'c')
+            ->where('d.name = ?1')
+            ->setParameter(1, 'John Doe')
+            ->getQuery()
+            ->getArrayResult();
+
+        $this->assertCount(1, $result);
+        $this->assertArrayHasKey('freeDriverRides', $result[0]);
+        $this->assertCount(3, $result[0]['freeDriverRides']);
+    }
+
+    /**
+     * 1) PaidRide contains an extra column that is not part of the composite primary key
+     * 2) Again we will use fetch joins
+     */
+    public function testSelectFromInverseSideWithCompositePkUsingFetchJoins()
+    {
+        $qb = $this->_em->createQueryBuilder();
+
+        $result = $qb->select('d, dr, c')
+            ->from('Doctrine\Tests\Models\Taxi\Driver', 'd')
+            ->leftJoin('d.driverRides', 'dr')
+            ->leftJoin('dr.car', 'c')
+            ->where('d.name = ?1')
+            ->setParameter(1, 'John Doe')
+            ->getQuery()->getArrayResult();
+
+        $this->assertCount(1, $result);
+        $this->assertArrayHasKey('driverRides', $result[0]);
+        $this->assertCount(3, $result[0]['driverRides']);
+    }
+
+    /**
+     * The other way around will fail too
+     */
+    public function testSelectFromOwningSideUsingFetchJoins()
+    {
+        $qb = $this->_em->createQueryBuilder();
+
+        $result =  $qb->select('r, d, c')
+            ->from('Doctrine\Tests\Models\Taxi\PaidRide', 'r')
+            ->leftJoin('r.driver', 'd')
+            ->leftJoin('r.car', 'c')
+            ->where('d.name = ?1')
+            ->setParameter(1, 'John Doe')
+            ->getQuery()->getArrayResult();
+
+        $this->assertCount(3, $result);
+        $this->assertArrayHasKey('driver', $result[0]);
+        $this->assertArrayHasKey('car', $result[0]);
+    }
+}

tests/Doctrine/Tests/ORM/Functional/Ticket/DDC2350Test.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+/**
+ * @group DDC-2350
+ */
+class DDC2350Test extends OrmFunctionalTestCase
+{
+    protected function setUp()
+    {
+        parent::setUp();
+
+        $this->_schemaTool->createSchema(array(
+            $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2350User'),
+            $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2350Bug'),
+        ));
+    }
+
+    public function testEagerCollectionsAreOnlyRetrievedOnce()
+    {
+        $user = new DDC2350User();
+        $bug1 = new DDC2350Bug();
+        $bug1->user = $user;
+        $bug2 = new DDC2350Bug();
+        $bug2->user = $user;
+
+        $this->_em->persist($user);
+        $this->_em->persist($bug1);
+        $this->_em->persist($bug2);
+        $this->_em->flush();
+
+        $this->_em->clear();
+
+        $cnt = $this->getCurrentQueryCount();
+        $user = $this->_em->find(__NAMESPACE__ . '\DDC2350User', $user->id);
+
+        $this->assertEquals($cnt + 2, $this->getCurrentQueryCount());
+
+        $this->assertEquals(2, count($user->reportedBugs));
+
+        $this->assertEquals($cnt + 2, $this->getCurrentQueryCount());
+    }
+}
+
+/**
+ * @Entity
+ */
+class DDC2350User
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+    /** @OneToMany(targetEntity="DDC2350Bug", mappedBy="user", fetch="EAGER") */
+    public $reportedBugs;
+}
+
+/**
+ * @Entity
+ */
+class DDC2350Bug
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+    /** @ManyToOne(targetEntity="DDC2350User", inversedBy="reportedBugs") */
+    public $user;
+}

tests/Doctrine/Tests/ORM/Functional/Ticket/DDC2579Test.php

@@ -0,0 +1,180 @@
+<?php
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\DBAL\Types\StringType;
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+/**
+ * @group DDC-2579
+ */
+class DDC2579Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    protected function setUp()
+    {
+        parent::setUp();
+
+        Type::addType(DDC2579Type::NAME, DDC2579Type::CLASSNAME);
+
+        $this->_schemaTool->createSchema(array(
+            $this->_em->getClassMetadata(DDC2579Entity::CLASSNAME),
+            $this->_em->getClassMetadata(DDC2579EntityAssoc::CLASSNAME),
+            $this->_em->getClassMetadata(DDC2579AssocAssoc::CLASSNAME),
+        ));
+    }
+
+    public function testIssue()
+    {
+        $id         = new DDC2579Id("foo");
+        $assoc      = new DDC2579AssocAssoc($id);
+        $assocAssoc = new DDC2579EntityAssoc($assoc);
+        $entity     = new DDC2579Entity($assocAssoc);
+        $repository = $this->_em->getRepository(DDC2579Entity::CLASSNAME);
+
+        $this->_em->persist($assoc);
+        $this->_em->persist($assocAssoc);
+        $this->_em->persist($entity);
+        $this->_em->flush();
+        
+        $entity->value++;
+
+        $this->_em->persist($entity);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $id       = $entity->id;
+        $value    = $entity->value;
+        $criteria = array('assoc' => $assoc, 'id' => $id);
+        $entity   = $repository->findOneBy($criteria);
+
+        $this->assertInstanceOf(DDC2579Entity::CLASSNAME, $entity);
+        $this->assertEquals($value, $entity->value);
+
+        $this->_em->remove($entity);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $this->assertNull($repository->findOneBy($criteria));
+        $this->assertCount(0, $repository->findAll());
+    }
+}
+
+/**
+ * @Entity
+ */
+class DDC2579Entity
+{
+
+    const CLASSNAME = __CLASS__;
+
+    /**
+     * @Id
+     * @Column(type="ddc2579")
+     */
+    public $id;
+
+    /**
+     * @Id
+     * @ManyToOne(targetEntity="DDC2579EntityAssoc")
+     * @JoinColumn(name="relation_id", referencedColumnName="association_id")
+     */
+    public $assoc;
+
+    /**
+     * @Column(type="integer")
+     */
+    public $value;
+
+    public function __construct(DDC2579EntityAssoc $assoc, $value = 0)
+    {
+        $this->id    = $assoc->assocAssoc->associationId;
+        $this->assoc = $assoc;
+        $this->value = $value;
+    }
+
+}
+
+/**
+ * @Entity
+ */
+class DDC2579EntityAssoc
+{
+    const CLASSNAME = __CLASS__;
+
+    /**
+     * @Id
+     * @ManyToOne(targetEntity="DDC2579AssocAssoc")
+     * @JoinColumn(name="association_id", referencedColumnName="associationId")
+     */
+    public $assocAssoc;
+
+    public function __construct(DDC2579AssocAssoc $assocAssoc)
+    {
+        $this->assocAssoc = $assocAssoc;
+    }
+}
+
+/**
+ * @Entity
+ */
+class DDC2579AssocAssoc
+{
+    const CLASSNAME = __CLASS__;
+
+    /**
+     * @Id
+     * @Column(type="ddc2579")
+     */
+    public $associationId;
+
+    public function __construct(DDC2579Id $id)
+    {
+        $this->associationId  = $id;
+    }
+}
+
+
+class DDC2579Type extends StringType
+{
+    const NAME = 'ddc2579';
+    const CLASSNAME = __CLASS__;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function convertToDatabaseValue($value, AbstractPlatform $platform)
+    {
+        return (string)$value;
+    }
+
+    public function convertToPhpValue($value, AbstractPlatform $platform)
+    {
+        return new DDC2579Id($value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return self::NAME;
+    }
+}
+
+class DDC2579Id
+{
+    const CLASSNAME = __CLASS__;
+
+    private $val;
+
+    public function __construct($val)
+    {
+        $this->val = $val;
+    }
+
+    public function __toString()
+    {
+        return $this->val;
+    }
+}

tests/Doctrine/Tests/ORM/Functional/Ticket/DDC2660Test.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\ORM\Query\ResultSetMappingBuilder;
+use Doctrine\Common\Collections\ArrayCollection;
+
+/**
+ * @group
+ */
+class DDC2660Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    /**
+     * {@inheritDoc}
+     */
+    protected function setup()
+    {
+        parent::setup();
+
+        try {
+            $this->_schemaTool->createSchema(array(
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2660Product'),
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2660Customer'),
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2660CustomerOrder')
+            ));
+        } catch(\Exception $e) {
+            return;
+        }
+
+        for ($i = 0; $i < 5; $i++) {
+            $product = new DDC2660Product();
+            $customer = new DDC2660Customer();
+            $order = new DDC2660CustomerOrder($product, $customer, 'name' . $i);
+
+            $this->_em->persist($product);
+            $this->_em->persist($customer);
+            $this->_em->flush();
+
+            $this->_em->persist($order);
+            $this->_em->flush();
+        }
+
+        $this->_em->clear();
+    }
+
+    public function testIssueWithExtraColumn()
+    {
+        $sql = "SELECT o.product_id, o.customer_id, o.name FROM ddc_2660_customer_order o";
+
+        $rsm = new ResultSetMappingBuilder($this->_getEntityManager());
+        $rsm->addRootEntityFromClassMetadata(__NAMESPACE__ . '\DDC2660CustomerOrder', 'c');
+
+        $query  = $this->_em->createNativeQuery($sql, $rsm);
+        $result = $query->getResult();
+
+        $this->assertCount(5, $result);
+
+        foreach ($result as $order) {
+            $this->assertNotNull($order);
+            $this->assertInstanceOf(__NAMESPACE__ . '\\DDC2660CustomerOrder', $order);
+        }
+    }
+
+    public function testIssueWithoutExtraColumn()
+    {
+        $sql = "SELECT o.product_id, o.customer_id FROM ddc_2660_customer_order o";
+
+        $rsm = new ResultSetMappingBuilder($this->_getEntityManager());
+        $rsm->addRootEntityFromClassMetadata(__NAMESPACE__ . '\DDC2660CustomerOrder', 'c');
+
+        $query  = $this->_em->createNativeQuery($sql, $rsm);
+        $result = $query->getResult();
+
+        $this->assertCount(5, $result);
+
+        foreach ($result as $order) {
+            $this->assertNotNull($order);
+            $this->assertInstanceOf(__NAMESPACE__ . '\\DDC2660CustomerOrder', $order);
+        }
+    }
+}
+/**
+ * @Entity @Table(name="ddc_2660_product")
+ */
+class DDC2660Product
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+}
+
+/** @Entity  @Table(name="ddc_2660_customer") */
+class DDC2660Customer
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+}
+
+/** @Entity @Table(name="ddc_2660_customer_order") */
+class DDC2660CustomerOrder
+{
+    /**
+     * @Id @ManyToOne(targetEntity="DDC2660Product")
+     */
+    public $product;
+
+    /**
+     * @Id @ManyToOne(targetEntity="DDC2660Customer")
+     */
+    public $customer;
+
+    /**
+     * @Column(type="string")
+     */
+    public $name;
+
+    public function __construct(DDC2660Product $product, DDC2660Customer $customer, $name)
+    {
+        $this->product  = $product;
+        $this->customer = $customer;
+        $this->name = $name;
+    }
+}

tests/Doctrine/Tests/ORM/Functional/Ticket/DDC2759Test.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+/**
+ * @group DDC-2759
+ */
+class DDC2759Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    /**
+     * {@inheritDoc}
+     */
+    protected function setup()
+    {
+        parent::setup();
+
+        try {
+            $this->_schemaTool->createSchema(array(
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2759Qualification'),
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2759Category'),
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2759QualificationMetadata'),
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2759MetadataCategory'),
+            ));
+        } catch(\Exception $e) {
+            return;
+        }
+
+        $qualification = new DDC2759Qualification();
+        $qualificationMetadata = new DDC2759QualificationMetadata($qualification);
+
+        $category1 = new DDC2759Category();
+        $category2 = new DDC2759Category();
+
+        $metadataCategory1 = new DDC2759MetadataCategory($qualificationMetadata, $category1);
+        $metadataCategory2 = new DDC2759MetadataCategory($qualificationMetadata, $category2);
+
+        $this->_em->persist($qualification);
+        $this->_em->persist($qualificationMetadata);
+
+        $this->_em->persist($category1);
+        $this->_em->persist($category2);
+
+        $this->_em->persist($metadataCategory1);
+        $this->_em->persist($metadataCategory2);
+
+        $this->_em->flush();
+        $this->_em->clear();
+    }
+
+    public function testCorrectNumberOfAssociationsIsReturned()
+    {
+        $repository = $this->_em->getRepository(__NAMESPACE__ . '\DDC2759Qualification');
+
+        $builder = $repository->createQueryBuilder('q')
+            ->select('q, qm, qmc')
+            ->innerJoin('q.metadata', 'qm')
+            ->innerJoin('qm.metadataCategories', 'qmc');
+
+        $result = $builder->getQuery()
+            ->getArrayResult();
+
+        $this->assertCount(2, $result[0]['metadata']['metadataCategories']);
+    }
+}
+
+/** @Entity  @Table(name="ddc_2759_qualification") */
+class DDC2759Qualification
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+
+    /** @OneToOne(targetEntity="DDC2759QualificationMetadata", mappedBy="content") */
+    public $metadata;
+}
+
+/** @Entity  @Table(name="ddc_2759_category") */
+class DDC2759Category
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+
+    /** @OneToMany(targetEntity="DDC2759MetadataCategory", mappedBy="category") */
+    public $metadataCategories;
+}
+
+/** @Entity  @Table(name="ddc_2759_qualification_metadata") */
+class DDC2759QualificationMetadata
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+
+    /** @OneToOne(targetEntity="DDC2759Qualification", inversedBy="metadata") */
+    public $content;
+
+    /** @OneToMany(targetEntity="DDC2759MetadataCategory", mappedBy="metadata") */
+    protected $metadataCategories;
+
+    public function __construct(DDC2759Qualification $content)
+    {
+        $this->content = $content;
+    }
+}
+
+/** @Entity  @Table(name="ddc_2759_metadata_category") */
+class DDC2759MetadataCategory
+{
+    /** @Id @Column(type="integer") @GeneratedValue */
+    public $id;
+
+    /** @ManyToOne(targetEntity="DDC2759QualificationMetadata", inversedBy="metadataCategories") */
+    public $metadata;
+
+    /** @ManyToOne(targetEntity="DDC2759Category", inversedBy="metadataCategories") */
+    public $category;
+
+    public function __construct(DDC2759QualificationMetadata $metadata, DDC2759Category $category)
+    {
+        $this->metadata = $metadata;
+        $this->category = $category;
+    }
+}

tests/Doctrine/Tests/ORM/Functional/Ticket/DDC2984Test.php

@@ -0,0 +1,199 @@
+<?php
+
+namespace Doctrine\Tests\ORM\Functional\Ticket;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Types\ConversionException;
+use Doctrine\DBAL\Types\StringType;
+use Doctrine\DBAL\Types\Type;
+
+/**
+ * @group DDC-2984
+ */
+class DDC2984Test extends \Doctrine\Tests\OrmFunctionalTestCase
+{
+    public function setUp()
+    {
+        parent::setUp();
+        
+        if ( ! Type::hasType('ddc2984_domain_user_id')) {
+            Type::addType(
+                'ddc2984_domain_user_id', 
+                __NAMESPACE__ . '\DDC2984UserIdCustomDbalType'
+            );
+        }
+
+        try {
+            $this->_schemaTool->createSchema(array(
+                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC2984User'),
+            ));
+        } catch (\Exception $e) {
+            // no action needed - schema seems to be already in place
+        }
+    }
+
+    public function testIssue()
+    {
+        $user = new DDC2984User(new DDC2984DomainUserId('unique_id_within_a_vo'));
+        $user->applyName('Alex');
+        
+        $this->_em->persist($user);
+        $this->_em->flush($user);
+        
+        $repository = $this->_em->getRepository(__NAMESPACE__ . "\DDC2984User");
+
+        $sameUser = $repository->find(new DDC2984DomainUserId('unique_id_within_a_vo'));
+
+        //Until know, everything works as expected
+        $this->assertTrue($user->sameIdentityAs($sameUser));
+
+        $this->_em->clear();
+
+        //After clearing the identity map, the UnitOfWork produces the warning described in DDC-2984
+        $equalUser = $repository->find(new DDC2984DomainUserId('unique_id_within_a_vo'));
+
+        $this->assertNotSame($user, $equalUser);
+        $this->assertTrue($user->sameIdentityAs($equalUser));
+    }
+}
+
+/** @Entity @Table(name="users") */
+class DDC2984User
+{
+    /**
+     * @Id @Column(type="ddc2984_domain_user_id")
+     * @GeneratedValue(strategy="NONE")
+     *
+     * @var DDC2984DomainUserId
+     */
+    private $userId;
+
+    /** @Column(type="string", length=50) */
+    private $name;
+
+    public function __construct(DDC2984DomainUserId $aUserId)
+    {
+        $this->userId = $aUserId;
+    }
+
+    /**
+     * @return DDC2984DomainUserId
+     */
+    public function userId()
+    {
+        return $this->userId;
+    }
+
+    /**
+     * @return string
+     */
+    public function name()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @param string $name
+     */
+    public function applyName($name)
+    {
+        $this->name = $name;
+    }
+
+    /**
+     * @param DDC2984User $other
+     * @return bool
+     */
+    public function sameIdentityAs(DDC2984User $other)
+    {
+        return $this->userId()->sameValueAs($other->userId());
+    }
+}
+
+/**
+ * DDC2984DomainUserId ValueObject
+ *
+ * @author Alexander Miertsch <kontakt@codeliner.ws>
+ */
+class DDC2984DomainUserId
+{
+    /**
+     * @var string
+     */
+    private $userIdString;
+
+    /**
+     * @param string $aUserIdString
+     */
+    public function __construct($aUserIdString)
+    {
+        $this->userIdString = $aUserIdString;
+    }
+
+    /**
+     * @return string
+     */
+    public function toString()
+    {
+        return $this->userIdString;
+    }
+
+    /**
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->toString();
+    }
+
+    /**
+     * @param DDC2984DomainUserId $other
+     * @return bool
+     */
+    public function sameValueAs(DDC2984DomainUserId $other)
+    {
+        return $this->toString() === $other->toString();
+    }
+} 
+
+/**
+ * Class DDC2984UserIdCustomDbalType
+ *
+ * @author Alexander Miertsch <kontakt@codeliner.ws>
+ */
+class DDC2984UserIdCustomDbalType extends StringType
+{
+    public function getName()
+    {
+        return 'ddc2984_domain_user_id';
+    }
+    /**
+     * {@inheritDoc}
+     */
+    public function convertToPHPValue($value, AbstractPlatform $platform)
+    {
+        return ! empty($value)
+            ? new DDC2984DomainUserId($value)
+            : null;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function convertToDatabaseValue($value, AbstractPlatform $platform)
+    {
+        if (empty($value)) {
+            return null;
+        }
+
+        if (is_string($value)) {
+            return $value;
+        }
+
+        if ( ! $value instanceof DDC2984DomainUserId) {
+            throw ConversionException::conversionFailed($value, $this->getName());
+        }
+
+        return $value->toString();
+    }
+} 

tests/Doctrine/Tests/ORM/Functional/Ticket/DDC742Test.php

@@ -76,7 +76,7 @@ class DDC742Test extends \Doctrine\Tests\OrmFunctionalTestCase
 
 /**
  * @Entity
- * @Table(name="users")
+ * @Table(name="ddc742_users")
  */
 class DDC742User
 {
@@ -109,7 +109,7 @@ class DDC742User
 
 /**
  * @Entity
- * @Table(name="comments")
+ * @Table(name="ddc742_comments")
  */
 class DDC742Comment
 {

tests/Doctrine/Tests/ORM/Mapping/ClassMetadataTest.php

@@ -977,6 +977,31 @@ class ClassMetadataTest extends \Doctrine\Tests\OrmTestCase
 
         $cm->setAttributeOverride('name', array('type'=>'date'));
     }
+
+    /**
+     * @group DDC-2608
+     */
+    public function testSetSequenceGeneratorThrowsExceptionWhenSequenceNameIsMissing()
+    {
+        $cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
+        $cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
+
+        $this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
+        $cm->setSequenceGeneratorDefinition(array());
+    }
+
+    /**
+     * @group DDC-2662
+     */
+    public function testQuotedSequenceName()
+    {
+        $cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
+        $cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
+
+        $cm->setSequenceGeneratorDefinition(array('sequenceName' => '`foo`'));
+
+        $this->assertEquals(array('sequenceName' => 'foo', 'quoted' => true), $cm->sequenceGeneratorDefinition);
+    }
 }
 
 class MyNamespacedNamingStrategy extends \Doctrine\ORM\Mapping\DefaultNamingStrategy

tests/Doctrine/Tests/ORM/PersistentCollectionTest.php

@@ -6,16 +6,21 @@ use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\ORM\PersistentCollection;
 use Doctrine\Tests\Mocks\ConnectionMock;
 use Doctrine\Tests\Mocks\EntityManagerMock;
-use Doctrine\Tests\Models\ECommerce\ECommerceProduct;
-
-require_once __DIR__ . '/../TestInit.php';
+use Doctrine\Tests\Models\ECommerce\ECommerceCart;
+use Doctrine\Tests\OrmTestCase;
 
 /**
- * Tests the lazy-loading capabilities of the PersistentCollection.
+ * Tests the lazy-loading capabilities of the PersistentCollection and the initialization of collections.
  * @author Giorgio Sironi <piccoloprincipeazzurro@gmail.com>
+ * @author Austin Morris <austin.morris@gmail.com>
  */
-class PersistentCollectionTest extends \Doctrine\Tests\OrmTestCase
+class PersistentCollectionTest extends OrmTestCase
 {
+    /**
+     * @var PersistentCollection
+     */
+    protected $collection;
+
     private $_connectionMock;
     private $_emMock;
 
@@ -27,6 +32,17 @@ class PersistentCollectionTest extends \Doctrine\Tests\OrmTestCase
         $this->_emMock = EntityManagerMock::create($this->_connectionMock);
     }
 
+    /**
+     * Set up the PersistentCollection used for collection initialization tests.
+     */
+    public function setUpPersistentCollection()
+    {
+        $classMetaData = $this->_emMock->getClassMetadata('Doctrine\Tests\Models\ECommerce\ECommerceCart');
+        $this->collection = new PersistentCollection($this->_emMock, $classMetaData, new ArrayCollection);
+        $this->collection->setInitialized(false);
+        $this->collection->setOwner(new ECommerceCart(), $classMetaData->getAssociationMapping('products'));
+    }
+
     public function testCanBePutInLazyLoadingMode()
     {
         $class = $this->_emMock->getClassMetadata('Doctrine\Tests\Models\ECommerce\ECommerceProduct');
@@ -34,4 +50,34 @@ class PersistentCollectionTest extends \Doctrine\Tests\OrmTestCase
         $collection->setInitialized(false);
         $this->assertFalse($collection->isInitialized());
     }
+
+    /**
+     * Test that PersistentCollection::current() initializes the collection.
+     */
+    public function testCurrentInitializesCollection()
+    {
+        $this->setUpPersistentCollection();
+        $this->collection->current();
+        $this->assertTrue($this->collection->isInitialized());
+    }
+
+    /**
+     * Test that PersistentCollection::key() initializes the collection.
+     */
+    public function testKeyInitializesCollection()
+    {
+        $this->setUpPersistentCollection();
+        $this->collection->key();
+        $this->assertTrue($this->collection->isInitialized());
+    }
+
+    /**
+     * Test that PersistentCollection::next() initializes the collection.
+     */
+    public function testNextInitializesCollection()
+    {
+        $this->setUpPersistentCollection();
+        $this->collection->next();
+        $this->assertTrue($this->collection->isInitialized());
+    }
 }

tests/Doctrine/Tests/ORM/Persisters/BasicEntityPersisterTypeValueSqlTest.php

@@ -96,6 +96,18 @@ class BasicEntityPersisterTypeValueSqlTest extends \Doctrine\Tests\OrmTestCase
     public function testSelectConditionStatementIsNull()
     {
         $statement = $this->_persister->getSelectConditionStatementSQL('test', null, array(), Comparison::IS);
-        $this->assertEquals('test IS ?', $statement);
+        $this->assertEquals('test IS NULL', $statement);
+    }
+
+    public function testSelectConditionStatementEqNull()
+    {
+        $statement = $this->_persister->getSelectConditionStatementSQL('test', null, array(), Comparison::EQ);
+        $this->assertEquals('test IS NULL', $statement);
+    }
+
+    public function testSelectConditionStatementNeqNull()
+    {
+        $statement = $this->_persister->getSelectConditionStatementSQL('test', null, array(), Comparison::NEQ);
+        $this->assertEquals('test IS NOT NULL', $statement);
     }
 }

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

@@ -105,6 +105,8 @@ class QueryTest extends \Doctrine\Tests\OrmTestCase
         $this->assertEquals('bar', $q->getHint('foo'));
         $this->assertEquals('baz', $q->getHint('bar'));
         $this->assertEquals(array('foo' => 'bar', 'bar' => 'baz'), $q->getHints());
+        $this->assertTrue($q->hasHint('foo'));
+        $this->assertFalse($q->hasHint('barFooBaz'));
     }
 
     /**

tests/Doctrine/Tests/ORM/Query/SelectSqlGenerationTest.php

@@ -1710,6 +1710,18 @@ class SelectSqlGenerationTest extends \Doctrine\Tests\OrmTestCase
             'SELECT q0_."group-id" AS groupid0, q0_."group-name" AS groupname1, q1_."group-id" AS groupid2, q1_."group-name" AS groupname3 FROM "quote-group" q0_ INNER JOIN "quote-group" q1_ ON q0_."parent-id" = q1_."group-id"'
         );
     }
+
+    /**
+     * @group DDC-2506
+     */
+    public function testClassTableInheritanceJoinWithConditionAppliesToBaseTable()
+    {
+        $this->assertSqlGeneration(
+            'SELECT e.id FROM Doctrine\Tests\Models\Company\CompanyOrganization o JOIN o.events e WITH e.id = ?1',
+            'SELECT c0_.id AS id0 FROM company_organizations c1_ INNER JOIN company_events c0_ ON c1_.id = c0_.org_id AND (c0_.id = ?) LEFT JOIN company_auctions c2_ ON c0_.id = c2_.id LEFT JOIN company_raffles c3_ ON c0_.id = c3_.id',
+            array(Query::HINT_FORCE_PARTIAL_LOAD => false)
+        );
+    }
 }
 
 class MyAbsFunction extends \Doctrine\ORM\Query\AST\Functions\FunctionNode

tests/Doctrine/Tests/ORM/Tools/EntityGeneratorTest.php

@@ -516,9 +516,9 @@ class EntityGeneratorTest extends \Doctrine\Tests\OrmTestCase
             )),
             array(array(
                 'fieldName' => 'decimal',
-                'phpType' => 'float',
+                'phpType' => 'string',
                 'dbType' => 'decimal',
-                'value' => 33.33
+                'value' => '12.34'
             ),
         ));
     }

tests/Doctrine/Tests/OrmFunctionalTestCase.php

@@ -124,6 +124,12 @@ abstract class OrmFunctionalTestCase extends OrmTestCase
             'Doctrine\Tests\Models\CustomType\CustomTypeParent',
             'Doctrine\Tests\Models\CustomType\CustomTypeUpperCase',
         ),
+        'taxi' => array(
+            'Doctrine\Tests\Models\Taxi\PaidRide',
+            'Doctrine\Tests\Models\Taxi\Ride',
+            'Doctrine\Tests\Models\Taxi\Car',
+            'Doctrine\Tests\Models\Taxi\Driver',
+        ),
     );
 
     protected function useModelSet($setName)
@@ -239,6 +245,14 @@ abstract class OrmFunctionalTestCase extends OrmTestCase
             $conn->executeUpdate('DELETE FROM customtype_uppercases');
         }
 
+
+        if (isset($this->_usedModelSets['taxi'])) {
+            $conn->executeUpdate('DELETE FROM taxi_paid_ride');
+            $conn->executeUpdate('DELETE FROM taxi_ride');
+            $conn->executeUpdate('DELETE FROM taxi_car');
+            $conn->executeUpdate('DELETE FROM taxi_driver');
+        }
+
         $this->_em->clear();
     }