I am facing a small issue on Doctrine 2 that causes OneToOne relation needed to be part of the parent class. The error occurs when doing $content->getVersions() but not when doing $em->find("Model\Lantern\Content\Version", $id). The error message is:

Warning: Undefined index: summary in ORM/UnitOfWork.php:2012
Fatal error: Call to a member function setValue() on a non-object in ORM/UnitOfWork.php on line 2013

Error replication:

Simply by having a look at the model we can see what's causing the Bug, will avoid class annotations to make it simpler:

class Content{
    /**
    * @OneToMany(targetEntity="Version", mappedBy="content")
    */
    private $versions;
...
}

class Version{
    /**
     * @ManyToOne(targetEntity="Content", inversedBy="versions")
     * @JoinColumn(name="content_id", referencedColumnName="content_id")
     */
    private $content;
...
}

class Article extends Version{
    /** @OneToOne(targetEntity="Model\Lantern\Content\Fieldset\Summary", mappedBy="version", cascade={"persist", "delete"}) */
    private $summary;  
...
}

class Summary{
    /**
     * @OneToOne(targetEntity="Model\Lantern\Content\Version", inversedBy="summary")
     * @JoinColumn(name="version_id", referencedColumnName="version_id")
     */
    private $version;    
...
}

As you can see, Article::$summary targets Summary::$version, but Summary::$version targets Version::$summary. This in OOP is valid as Version is contained inside Article, so doing a downcasting will get Article::summary.

The reason I believe why using $em->find works is that $em->find already knows which child class is before doing map, and relations works fine.
On the other hand, when doing $content->getVersions(), Content::$versions targets Version, and looks like Doctrine does not resolve which child class it before mapping OneToOne relationshipg.

This bug doesn't occur with OneToMany or ManyToMany relationships.

Problem is that UnitOfWork::doMerge() calls ClassMetadata::getIdentifierValues() for the entity but that function doesn't have case for not initialized proxy. It just reads the Id properties from the object's reflection.

It should load the proxy or get the ID stored inside the proxy object or doMerge must initialize it maybe.

https://github.com/doctrine/doctrine2/blob/2.1.x/lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php#L343 `$className` should be `$class->name` this is fixed in master.

The bug is in ORM\Tools\Setup.php in the function registerAutoloadDirectory($directory), specificially the following line:

$loader = new ClassLoader("Doctrine");

Which should actually be:

$loader = new ClassLoader("Doctrine", $directory);

As it stands the actual directory location is not being passed to the ClassLoader while attempting to autoload the Doctrine from that specified directory. Under certain circumstances this causes loading to completely fail (although in cases where this function is being called from a parent directory to Doctrine this seems to go unnoticed - perhaps why this was not picked up sooner?)

Currently, it is impossible to provide an argument that is a collection of Entities. Example:

$userA = new CmsUser;
$userA->name = 'Benjamin';
$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);

$this->_em->flush();
$this->_em->clear();

$query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u IN (?0)");
$query->setParameter(0, array($userA, $userB));

Returns this error currently:

Object of class Doctrine\Tests\Models\CMS\CmsUser could not be converted to string

The classname given to the EntityPersister by the ProxyFactory includes a backslash '\' in front of the namespace while normal classes and the proxy itself don't have this. This issue causes it impossible to persist proxyclasses, because of the string comparison in UnitOfWork::executeUpdates in the statement [ get_parent_class($entity) == $className ] this will do 'some\namespace\someclass' == '\some\namespace\someclass'

Aftter some debugging work it seems the '\' is trimmed of when getting the ClassMetadata while this isn't done when a the proxyfactory creates the proxy. So it is probably fixed by placing:

$className = ltrim($className, '\');

at the start of ProxyFactory::getProxy where '\' is actually a double backslash but that cannot be posted here

This issue is created automatically through a Github pull request on behalf of Ringosan:

Url: https://github.com/doctrine/doctrine2/pull/112

Message:

Can either be changed here or in the method calls depending on your preference.

UnitOfWork::getEntityState checks for the state by using the id as one indicator. This can be created using a pre-insert generator though, which means the entity does not have to exist at all, even though an id was already generated.

Hi, I found really annoing bug in multi table update executor, it doesn't bind parameters properly. I have following structure of entities (afaik not really important, bug should appear with any class inheritance structure)

/**
* @entity
* @inheritanceType("JOINED")
* @discriminatorColumn(name="type", type="string")
* @discriminatorMap({"NodeEntity", forum = "ForumEntity"})
*/
class NodeEntity
{
  // ... some params
}

/**
* @entity
*/
class ForumEntity
{
/**
* @manyToOne(targetEntity="Author")
*/
private $lastPostAuthor;


/**
* @column(type="datetime")
*/
private $tLastPost;
// ... some params
}

And I'm trying to run following query

$qb = $this->entityManager->createQueryBuilder()
			->update('ForumEntity', 'f')
			->set('f.nPosts', 'f.nPosts + 1')
			->set('f.tLastPost', ':tLastPost')->setParameter('tLastPost', $post->getTCreation()) // $post->getTCreation() returns an instance of DateTime
			->set('f.lastPostAuthor', ':author')->setParameter('author', $post->getAuthor()) // $post->getAuthor() returns an instance of AuthorEntity

			->where('f.lft <= :left')->setParameter('left', $forum->getLft())
			->andWhere('f.rgt >= :right')->setParameter('right', $forum->getRgt())
			->andWhere('f.root = :root')->setParameter('root', $forum->getRoot());

		$qb->getQuery()->execute();

Which fails with "recoverable error", because Doctrine tries to convert value of parameter 'right' to datetime. I have learned why it does so, it is because of line 157 in already mentioned MultiTableUpdateExecutor - while parameters for the insert query are sliced of parameters from update clause, their types are not. And that is a bit problematic.

But that is not the only problem, if you look at line 161, the update query receives parameters as they were binded to QueryBuilder, so when I bind there an object, the update query receives the object instead of his identificator. That leads to error like "object ... could not be converted to string". And also, the update query does not receive any information about type of parameters, but I'm not sure if that is also a bug.

I'm not a native english speaker so if I explain things chaotically, just say so please, I'll try better .

When doing transactional multi table update using DQL query the changes are not rolled back after exception is raised after the update.

$em->transactional(function($entityManager) {
    $dql = "UPDATE ..."; // some multi table update DQL
    $query = $entityManager->createQuery($dql);
    $query->execute();

    throw new Exception();
});

This is because Doctrine executes "DROP TABLE" for temporary table created for the update but MySQL is doing commit right after DROP and CREATE statements automatically.

From PHP documentation:

"Some databases, including MySQL, automatically issue an implicit COMMIT when a database definition language (DDL) statement such as DROP TABLE or CREATE TABLE is issued within a transaction. The implicit COMMIT will prevent you from rolling back any other changes within the transaction boundary."

Something is weird here, example: Remove CmsUser that has CmsAddress

(I'm not sure it's a bug, it might be the way I configured Doctrine)

Sometime Doctrine fails to calculate the right commit order, and then it fails when flushing because some db constraints are failing. I hacked the CommitOrderCalculator so that it would print the list of the dependencies, and this is what I found:
(I don't have time to write code now, so I'll try to explain it with words. If it's not clear I'll find some time tomorrow to hack together a test)

Let's say that we have the class User. The class user is connected to other classes (News, Comment, Post) with an unidirectional relation, so that User doesn't know anything about the other class.

Let's say we create a User and we save it. The CommitOrderCalculator will calculate the dependencies on User. This is a partial list, some dependencies won't be there (not sure whether it's because they haven't been loaded yet, whether it's because they are not part of the UnitOfWork or whether it's because User doesn't know about them) ***

Let's say that later, in the same request, we create a News. CommitOrderCalculator will calculate the dependencies for News. However, for User it will use the cached dependencies, and it won't realize that now User is required for News.

• • • Could it be a configuration problem?
      Are the dependencies supposed to be incomplete? (it seems reasonable as long as they are calculated for a single UnitOfWork, but it seems wrong if the dependencies are shared with multiple transactions)
      Or am I loading the classes in the wrong way?

Code references:
UnitOfWork::getCommitOrder line ~840
The class is added to $newNodes (the array used to calculate dependencies) only if the CommitOrderCalculator doesn't know the class already

CommitOrderCalculator::getCommitOrder line ~ 83
After getting the order _sorted and _nodeStates are reset, while _classes and _relatedClasses are not.

Basically UnitOfWork register the class only once, and CommitOrderCalculator doesn't forget about the class when the UnitOfWork ends.

Possible fix:

• Resetting _classes and _relatedClasses seem to fix the problem, but I don't know what was the rationale for not doing it, so I'm unclear whether it's the right think or not.

Example:
Dependencies calculated with the current code
Visiting Users\Model\User
+ Forum\Model\Forum
Visiting Forum\Model\Forum
+ Forum\Model\Forum
+ Forum\Model\Topic
Visiting Forum\Model\Topic
+ Forum\Model\Topic
+ Forum\Model\Topic
Visiting Forum\Model\Post
+ Forum\Model\Forum
+ Forum\Model\Topic
+ Forum\Model\Topic

Dependencies calculated with the reset
Visiting Forum\Model\Topic
+ Forum\Model\Post
Visiting Forum\Model\Post
+ Forum\Model\Topic
+ Forum\Model\Topic
+ Forum\Model\Forum
Visiting Forum\Model\Forum
+ Forum\Model\Topic
+ Forum\Model\Forum
Visiting Users\Model\User
+ Forum\Model\Topic
+ Forum\Model\Topic
+ Forum\Model\Post
+ Forum\Model\Post
+ Forum\Model\Forum

            $qb->from('Tournaments_Model_StageBracketTeamRegistration', 'r')
               ->innerJoin('r.teamSelection', 'ts')
               ->innerJoin('ts.players', 'tsp')
               ->select('r, ts, tsp')
               ->where('r.stageBracket = ?1')
               ->andWhere('r.opponentIsReserve = false')
               ->orderBy('r.registrationDateTime')
               ->setParameter(1, $bracket);

Generates:

SELECT s0_.id AS id0, s0_.opponent_is_reserve AS opponent_is_reserve1, s0_.opponent_checked_in AS opponent_checked_in2, s0_.registration_date_time AS registration_date_time3, t1_.id AS id4,, s0_.type AS type5, s0_.stage_bracket_id AS stage_bracket_id6, s2_.team_selection_id AS team_selection_id7, t1_.team_id AS team_id8, t3_.team_selection_id AS team_selection_id9, t3_.player_id AS player_id10
FROM stage_bracket_team_registrations s2_
INNER JOIN stage_bracket_registrations s0_ ON s2_.id = s0_.id
INNER JOIN team_selections t1_ ON s2_.team_selection_id = t1_.id
INNER JOIN team_selection_players t3_ ON t1_.id = t3_.team_selection_id
WHERE s0_.stage_bracket_id = 22 AND s0_.opponent_is_reserve = 0
ORDER BY s0_.registration_date_time ASC

Note the 2nd comma after "t1_.id AS id4". TeamSelectionPlayer uses a composite PK. I have attached the relevant entity classes.

Let's assume we have an Entity class "ParentClass", which uses a single table inheritance with child classes "ChildOne" and "ChildTwo".
"ParentClass" also have one-to-one unidirectional association with "FooBar" class named "foobar", and a self-referencing association called "parent"

We construct entity of "ChildOne" type, filling "foobar" link with new FooBar object. The same action is made for entity of "ChildTwo" type.
Entity of "ChildOne" type is persisted and flushed.

At this point getCommitOrder builds a commit order. ChildOne <---> FooBar link appears in dependency graph because of "foobar" association.
While processing assocs it reveals "parent" assoc in parent class and builds following links in dependency graph:
ChildOne <---> ChildOne
ChildOne <---> ChildTwo

After that "ChildTwo" entity is persisted and flushed. At this point commit calculator thinks it already have "ChildTwo" in it's storage so no assoc calculation are made for "childTwo" class

If we attemp to delete "ChildTwo" class flush() will fail because of missing link "ChildTwo <-----> Foobar" assoc

It would be both practical and intuitive to support the "repositoryClass" metadata property on a MappedSuperClass. Any subclasses would inherit that custom Repo class, optionally overriding it.

With the current situation one would have to add the property to every subclass, which may lead to a lot of duplicate meta data.