One to one entity over populated

If an association is joined during fetching and then updated in-memory, the update is not detected during flushing. I made the following test cases:

Association is joined:

• change NULL → entity: does not work
• change entity → NULL: works
• change entity1 → entity2: does not work

Assocation is not joined:

• change NULL → entity: works
• change entity → NULL: works
• change entity1 → entity2: works

When using the association-key attribute on an id element in an XML mapping, a MappingException is thrown:

[Doctrine\ORM\Mapping\MappingException]
No identifier/primary key specified for Entity 'Foo\BarBundle\Entity\Baz'. Every Entity must have an identifier/primary key.

This is because in the XMLDriver.php file (version 2.1.2)

Line 213 reads: $associationIds[(string)$idElement['fieldName']] = true;

When it should read: $associationIds[(string)$idElement['name']] = true;

This was fixed on master here, but has not be back ported – as I understand it master is 2.x. This is a fairly significant issues for users of the XMLDriver, currently a show stopper on our work, especially as we're using Symfony Standard distribution 2.0.6 – 2.0.7 references a version of Doctrine with another bug.

I've confirmed that this bug exists in 2.1.2, and 2.1.4, but it probably effects more versions.

See issue here https://github.com/symfony/symfony/issues/2336#issuecomment-3102931

It is because of the line https://github.com/doctrine/doctrine2/commit/a99ffc126f3ec3fa45fa806bfdba4fc31f1afaa4#L0R1460 where non-strict comparison is done for collection objects.

I would suggest traversing the elements of the both collections and comparing them using the strict "===" operator.

If all entities that are marked to be loaded eagerly are loaded through other references before UnitOfWork->triggerEagerLoads is executed an exception will be thrown as the value of the array is empty.

    public function triggerEagerLoads()
    {
        if (!$this->eagerLoadingEntities) {
            return;
        }

        // avoid infinite recursion
        $eagerLoadingEntities = $this->eagerLoadingEntities;
        $this->eagerLoadingEntities = array();

        foreach ($eagerLoadingEntities AS $entityName => $ids) {
            $class = $this->em->getClassMetadata($entityName);
            $this->getEntityPersister($entityName)->loadAll(array_combine($class->identifier, array(array_values($ids))));
        }
    }

I got a сatchable error when merging entity that has a composite PK with association FK:

Catchable Fatal Error: Object of class TestBundle\Entity\Foo could not be converted to string in /home/context/httpd/vendor/doctrine/lib/Doctrine/ORM/UnitOfWork.php line 2606

Entities and their mapping:

use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\ArrayCollection;

/**
 * @ORM\Entity
 */
class Foo
{
    /**
     * @ORM\Column(type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue
     */
    public $id;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    public $name;

    /**
     * @ORM\OneToMany(targetEntity="FooHasBar", mappedBy="foo", cascade={"persist", "remove", "merge"})
     */
    public $children;

    public function __construct()
    {
        $this->children = new ArrayCollection();
    }
}

/**
 * @ORM\Entity
 */
class Bar
{
    /**
     * @ORM\Column(type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue
     */
    public $id;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    public $name;
}

/**
 * @ORM\Entity
 */
class FooHasBar
{
    /**
     * @ORM\Id
     * @ORM\ManyToOne(targetEntity="Foo", inversedBy="children")
     * @ORM\JoinColumn(name="foo_id", referencedColumnName="id", nullable=false)
     */
    public $foo;

    /**
     * @ORM\Column(type="integer")
     * @ORM\Id
     */
    public $mode;

    /**
     * @ORM\ManyToOne(targetEntity="Bar")
     * @ORM\JoinColumn(name="bar_id", referencedColumnName="id", nullable=false)
     */
    public $bar;

    public function __construct(Foo $foo, Bar $bar, $mode)
    {
        $this->foo = $foo;
        $this->bar = $bar;
        $this->mode = $mode;
    }
}

Test entities attached.

Simillar issue to DDC-1452. Somtime (yes, this bug is not easy to reproduce...) when you fetch objects with multiple join cross the same table (as in DDC-1452 issue), some joins are ignored and multiple queries are necessary to lazy load relations.

I will attach falling test case soon.