First off, here's a pastie with all the code and mappings involved, and a stacktrace: http://pastie.org/5372087

Not sure if this a bug or not, but I think that according to the docs this should work - in a vendor bundle I have an entity defining a unidirectional many-to-many relation to an interface: the entity is Group and defines a many-to-many relation to a UserInterface, which is resolved correctly in the app configuration (as the many-to-one relations using it in the other entities of this vendor bundle work fine).

I'm going by these docs:

http://symfony.com/doc/master/cookbook/doctrine/resolve_target_entity.html

However, when adding a user to a group, I'm getting a weird error:

An exception occurred while executing 'INSERT INTO acme_group_user (group_id, user_id) VALUES (?, ?)' with params

:

SQLSTATE[HY093]: Invalid parameter number: number of bound variables does not match number of tokens

For some reason it's adding 4 parameters to the statement instead of 2.

Oddly enough, the query generation works perfectly fine when I replace the interface in the mapping with the actual final entity. But that wasn't the point of the exercise... I need to use the interface there.

Also, in other entities in that GroupBundle which are referencing the UserInterface using a different relation type, i.e. many-to-one, the relations work perfectly fine.

The schema validates as well, using doctrine:schema:validate in the console.

When I run doctrine orm:clear-cache:metadata I noticed that it clears everything within the cache, even items which have nothing to do with Doctrine at all.

In looking into the various driver implementations it seems that the AbstractCache->deleteAll() depends on getIds of each cache driver, yet the getIds of XcacheCache and MemcacheCache drivers seem to just get every single item within the cache.

This has several implications:

1. clearing metadata cache actually clears query cache and any other Doctrine cache using the same cache driver
2. clearing Doctrine cache of one project actually clears caches of every project using the same cache container
3. clearing Doctrine cache clears every object cached within that container, leading to increased risk of cache stampeding

In looking at the stored cache data it seems possible to fix #2 by using the Namespace of that project when executing a cache clear. it also seems possible to use the cache driver's deleteByRegex() to solve #1 by deleting only items listed as metadata cache vs query cache. Fixing #1 and #2 automatically fixes concern #3

Or, as an alternative, I could suggest that deleteAll() in MetaDataCommand should be replaced by:

$cacheIds = $cacheDriver->deleteBySuffix('METADATA');

root@ubuntu-server-1110:/home/zerkms/src/doctrine2# phpunit
PHPUnit 3.6.10 by Sebastian Bergmann.

Configuration read from /home/zerkms/src/doctrine2/phpunit.xml.dist

.SSSSSS.........................EEEEEEEEEEEEEEEEEEEEEEEEEEEEE 61 / 1472 ( 4%)
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE.EEESE...SSSEEEEEEEEEEEEEE 122 / 1472 ( 8%)
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE 183 / 1472 ( 12%)
.EEEEEEESSESESEESESEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFEEEEE 244 / 1472 ( 16%)
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEESE 305 / 1472 ( 20%)
SSSEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFEEEEEEEEEEEEEEEEEE 366 / 1472 ( 24%)
EEEEEEEEEEESSSEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEESSSSSSSSS 427 / 1472 ( 29%)
SSSS...........SEEEEEEEEEEEEEEEEEEEEEEEEEESEEESEEEEEEEEEEEEEE 488 / 1472 ( 33%)
EEEEEEEEEEEEEEEEEEEEEEEEESEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE 549 / 1472 ( 37%)
EEEEEEEEEEEEEEEEEEEEEE.EEEEEEEEEEEEE.EEEEEEEEEEESSEEEEEEEEEEE 610 / 1472 ( 41%)
EEEEEEEEEEEEEEEEEEEEEEEEEE................................... 671 / 1472 ( 45%)
............................................................. 732 / 1472 ( 49%)
............................................................. 793 / 1472 ( 53%)
.............................................S............... 854 / 1472 ( 58%)
......S...................................................... 915 / 1472 ( 62%)
............................................................. 976 / 1472 ( 66%)
............................................................. 1037 / 1472 ( 70%)
............................................................. 1098 / 1472 ( 74%)
............................................................. 1159 / 1472 ( 78%)
............................................................. 1220 / 1472 ( 82%)
............................................................. 1281 / 1472 ( 87%)
............................................................. 1342 / 1472 ( 91%)
...........................S............S.................... 1403 / 1472 ( 95%)
.................................SSSSSSSS.PHP Fatal error: Class 'Doctrine\Tests\Mocks\EntityPersisterMock' not found in /home/zerkms/src/doctrine2/tests/Doctrine/Tests/ORM/UnitOfWorkTest.php on line 55

This (the fatal error) happens because of in ORM/Tools/SetupTest there is a condition in setUp() that marks test as skipped, but tearDown() is being invoked anyway (that is how phpunit works).

So tearDown() should run only in case if setUp() hasn't skipped the test, otherwise tearDown() deletes registered autoloaders

PS: other tests failed because I haven't set up any database

The PR261 [1] has two commits, but only one (the first one) was merged to 2.1 and 2.2

[1] - https://github.com/doctrine/doctrine2/pull/261

The QueryBuilder misses a way to make a query distinct.

Iterate with fetch join in class Application\Sonata\NewsBundle\Entity\Post using association tags not allowed.

SELECT o FROM Application\Sonata\NewsBundle\Entity\Post o LEFT JOIN o.tags s_tags LEFT JOIN o.author s_author WHERE ( o.id = :field_4f1f118cf04ff_id_0 OR o.id = :field_4f1f118cf04ff_id_1 OR o.id = :field_4f1f118cf04ff_id_2 )

The SqlWalker.php (line 742) does not check if the association is selected ...

The PR : https://github.com/doctrine/doctrine2/pull/271

I have add some uniqueConstraints in ClassMetadataInfo but the EntityGenerator does not create the annotations for this.

private function _generateTableAnnotation($metadata)
{
    $table = array();

    if (isset($metadata->table['schema'])) {
         $table[] = 'schema="' . $metadata->table['schema'] . '"';
    }

    if (isset($metadata->table['name'])) {
        $table[] = 'name="' . $metadata->table['name'] . '"';
    }

    return '@' . $this->_annotationsPrefix . 'Table(' . implode(', ', $table) . ')';
}

We should add pagination tools to the Doctrine\ORM\Tools\Pagination namespace. There are already 3 libraries out there that share the same code-base:

• https://github.com/KnpLabs/knp-components/tree/master/src/Knp/Component/Pager/Event/Subscriber/Paginate/Doctrine/ORM/Query
• https://github.com/beberlei/DoctrineExtensions
• https://github.com/whiteoctober/Pagerfanta

We should merge the currently best one of this into the code soon, as the cost of maintaining them is very high and their code is pretty stable by now.

Following works:
$entity = $em->find('Entity', 1);
$entity->setName('newName');
$em->persist($entity);
$em->flush($entity);

Following does NOT work:
$entity = new Entity();
$entity->setName('newName');
$em->persist($entity);
$em->flush($entity);

Reproduce
---------------

• I have an entity
• I'm loading an association (named 'myfield') inside a `LoadClassMetadata` event.

Error
------

Then i get this error : Notice: Undefined index: myfield in /vendor/doctrine/lib/Doctrine/ORM/UnitOfWork.php line 2473

Problem
-----------

It seems that here https://github.com/doctrine/doctrine2/blob/master/lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php#L294 we call the method 'wakeupReflection' before the loadClassMetadata event is dispatched.

A solution
-------------

I've created a patch (all tests pass) here https://github.com/gordonslondon/doctrine2/commit/0823cd54d0b2720f5e72aa9a29d16271904d99f0 that fixed the issue. Do you want a PR ?

Here's the PR : https://github.com/doctrine/doctrine2/pull/264

https://github.com/doctrine/doctrine2/commit/3bb803fd697d92d661f5b8cea473f75f46c34857

Git Bisect found this commit to lead to the following error:

$ phpunit -c postgresql.phpunit.xml --filter DDC-742
PHPUnit 3.6.5 by Sebastian Bergmann.

Configuration read from /home/benny/code/php/wsnetbeans/doctrine2/postgresql.phpunit.xml

E

Time: 12 seconds, Memory: 36.00Mb

There was 1 error:

1) Doctrine\Tests\ORM\Functional\Ticket\DDC742Test::testIssue
Exception: [PHPUnit_Framework_Error_Notice] Undefined index: 0000000016f5d67f000000001fa7794e

With queries:
11. SQL: 'INSERT INTO comments (content) VALUES (?)' Params: 'baz'
10. SQL: 'INSERT INTO comments (content) VALUES (?)' Params: 'bar'
9. SQL: 'INSERT INTO comments (content) VALUES (?)' Params: 'foo'
8. SQL: 'ALTER TABLE user_comments ADD CONSTRAINT FK_BF13722AF8697D13 FOREIGN KEY (comment_id) REFERENCES comments (id) NOT DEFERRABLE INITIALLY IMMEDIATE' Params: 
7. SQL: 'ALTER TABLE user_comments ADD CONSTRAINT FK_BF13722AA76ED395 FOREIGN KEY (user_id) REFERENCES users (id) NOT DEFERRABLE INITIALLY IMMEDIATE' Params: 
6. SQL: 'CREATE TABLE comments (id SERIAL NOT NULL, content VARCHAR(100) NOT NULL, PRIMARY KEY(id))' Params: 
5. SQL: 'CREATE INDEX IDX_BF13722AF8697D13 ON user_comments (comment_id)' Params: 
4. SQL: 'CREATE INDEX IDX_BF13722AA76ED395 ON user_comments (user_id)' Params: 
3. SQL: 'CREATE TABLE user_comments (user_id INT NOT NULL, comment_id INT NOT NULL, PRIMARY KEY(user_id, comment_id))' Params: 
2. SQL: 'CREATE TABLE users (id SERIAL NOT NULL, title VARCHAR(100) NOT NULL, PRIMARY KEY(id))' Params: 

Trace:
/home/benny/code/php/wsnetbeans/doctrine2/lib/Doctrine/ORM/UnitOfWork.php:2171
/home/benny/code/php/wsnetbeans/doctrine2/lib/Doctrine/ORM/Persisters/ManyToManyPersister.php:113
/home/benny/code/php/wsnetbeans/doctrine2/lib/Doctrine/ORM/Persisters/ManyToManyPersister.php:95
/home/benny/code/php/wsnetbeans/doctrine2/lib/Doctrine/ORM/Persisters/AbstractCollectionPersister.php:130
/home/benny/code/php/wsnetbeans/doctrine2/lib/Doctrine/ORM/Persisters/AbstractCollectionPersister.php:108
/home/benny/code/php/wsnetbeans/doctrine2/lib/Doctrine/ORM/UnitOfWork.php:310
/home/benny/code/php/wsnetbeans/doctrine2/lib/Doctrine/ORM/EntityManager.php:334
/home/benny/code/php/wsnetbeans/doctrine2/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC742Test.php:63


/home/benny/code/php/wsnetbeans/doctrine2/tests/Doctrine/Tests/OrmFunctionalTestCase.php:359

Since https://github.com/doctrine/doctrine2/pull/259 we identified an issue with the Persisters that are failing to check for entities that exist in UoW (managed and sched for insert) and are now being checked is they are part of Collection.
Also it missed some tests. It should be easy, just ->persist the entity then triggers Collection actions.

That case previously triggered a PHP error along the lines of:

Notice: Undefined index: 0000000062a3a7690000000033c91b26 in doctrine/lib/Doctrine/ORM/UnitOfWork.php line 2202
#0 doctrine/lib/Doctrine/ORM/Persisters/ManyToManyPersister.php(267): Doctrine\ORM\UnitOfWork->getEntityIdentifier(Object(Item))
#1 doctrine/lib/Doctrine/ORM/PersistentCollection.php(411): Doctrine\ORM\Persisters\ManyToManyPersister->contains(Object(Doctrine\ORM\PersistentCollection), Object(Item))
#2 Test.php(71): Doctrine\ORM\PersistentCollection->contains(Object(Item))

Associated PR: https://github.com/doctrine/doctrine2/pull/259

Example :

<unique-constraints>
<unique-constraint columns="permalink" />
<unique-constraint columns="code" />
</unique-constraints>

This will create :
CREATE UNIQUE INDEX UNIQ_6C3BF144F286BC32 ON shows (permalink);
CREATE UNIQUE INDEX 1 ON shows (code);

instead of :
CREATE UNIQUE INDEX UNIQ_6C3BF144F286BC32 ON shows (permalink);
CREATE UNIQUE INDEX UNIQ_6C3BF14477153098 ON shows (code);

The problem comme from SchemaTool, and the first key is a valid result because of "==" instead of "===" inside Table.php.

I have create a PR on Github.

As of
https://github.com/doctrine/doctrine2/blob/master/lib/Doctrine/ORM/Proxy/ProxyFactory.php#L214
and
https://github.com/doctrine/doctrine2/blob/master/lib/Doctrine/ORM/Proxy/ProxyFactory.php#L237
the current ProxyFactory isn't actually checking if the identifier getter has logic in it.
Current checks aren't enough/valid.

In my opinion the check should be matching following:

(public|protected)\s+function\s+getFieldname\s*(\s*)\s+

Not really experienced with regex, but currently cannot come up with a more secure check.

(I'm using doctrine 2.1.4.)

I'm trying to merge an Entity back to the UnitOfWork.
The Entity is created from a serialized object (The deserialzed Entity is a valid Entity Object. The only difference
is that it is not managed by Doctrine yet) and I'm using the merge
method of the EntityManager to get it in managed state again.

This results in a call of the Method doMerge() in the UnitOfWork
class.
This method takes the id of my deserialized Entity, that I want to
merge, and looks if an Entity with that id is already in doctrine
cache. If that is the case my deserialized Entity is merged with the
one in the cache. So far so good. But I've got the Problem, that the
Entity, which is in cache, is not initialized yet. It is not initialized because
this Entity has a relation to another Entity that a used earlier in code.
It's there but in uninitialized stat, because I did not access it yet.
So when my deserialized Entity and the one from cache gets merged, some field are
uninitialized (the id field, for example).

I fixed the problem by adding this piece of code in line 1446 in the
UnitOfWork class:
if(! $managedCopy->_isInitialized_)

Ok, my problem is this:

I have created a Query object. Now I'd like to get it's result cache driver.

My options:
1) Ask QueryCacheProfile for the driver. I can, but it's never populated by default so I always get just NULL.
2) Ask Query with getResultCacheDriver(), but wait, I can't, that's now deprecated
3) Ask from EM's configuration the result cache driver. This always works.

I propose that either the QueryCacheProfile is always populated with the Query's default result cache impl unless specifically overridden for the QueryCacheProfile

OR

Make getResultCacheDriver() not deprecated. Like the other two related methods, they are not deprecated, why should this one. Calling this could populate the QueryCacheProfile for future use like all the other (get cache ttl, id) methods.

My problem with with option 3) is "leaving the context of my method and the Query" (mentally of course). Why should I have to go poke around in EM's configuration when the result cache IS (or is easily obtainable behind the scenes) in the query object anyways?

I made a mistake when creating a @ManyToOne entity:

/**

• @ManyToOne(targetEntity="Entities\EntityA")
  */
  private $test;

However, I was setting Entities\EntityB into $test.

Doctrine2 doesn't check for this, resulting in a hard-to-find issue.

See DCOM-93 for more information

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/239

The autocompletion was missing so i was sad.

But hey, it's open source!

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/235

Allow ExporterDrivers that implement the exportClassMetadata() function to return FALSE when no content is available/needs to be written to a file by the AbstractExporter, preventing empty files to be generated foreach processed ClassMetadataInfo instance.

I'm currently generating Data Transfer Object class for my Entities, but not all Entities require it. Based on an Annotation I determine which DTO's will be generated and return FALSE otherwise. Currently this 'negative' return is not respected and a lot of empty files are created.

One to one entity over populated

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/228

Several lines like this one:

<field name="upgrades" type="int" column="Upgrades"/>

Were not flagged by orm:validate-schema as incorrect. Updating a related entity revealed the problem ("int" not being a proper type) at runtime.

Bug: orm:validate-schema should throw an error on incorrect column type.

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

Idea is:

/**
 * @ManyToOne(targetEntity="UserInterface")
 */

Would fire "onResolveTargetEntity" which is supposed to return details for resolving the interface to an actual implementation.

ClassMetadataBuilder class has some methods defined that call methods on AssociationBuilder class by different names, specifically the (set) part . e.g.

ClassMetadataBuilder method addManyToOne, calls setInversedBy, but is defined in AssociationBuilder as inversedBy. This trows a call to undefined method.

Which one is it ?

When I executed the following DQL, I get an error.

 
> php scripts/doctrine.php orm:run-dql "select o from OrderDetail o where (o.price + o.tax) * o.count > 10000"

  [Doctrine\ORM\Query\QueryException]
  [Syntax Error] line 0, col 69: Error: Expected =, <, <=, <>, >, >=, !=, got ')'

When I swap the left-hand expression and right-hand one, no error occurs.

> php scripts/doctrine.php orm:run-dql "select o from OrderDetail o where 10000 < (o.price + o.tax) * o.count"

array
  empty

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/214

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/213

Hi there,
I'm wondering myself if the QueryBuilder::getQuery is a good method name.
Actually, a getMethodObject makes me think that I can use many times the getMethodObject and work with the same object.
e.g :

```php
$qb->getQuery()->useResultCache (true);
$qb->getQuery()->execute();
```
In my code, the problem is that getQuery return a new instance of Query each time that I call getQuery.
Furthermore, the getQuery method invoke a createQuery method.

So, maybe the QueryBuiler::getQuery can store a reference to the created Query instance, and if the QueryBuilder::getQuery is call many times without any change return the stored instance.
If the QueryBuilder::getQuery have to generate a new Query, throw an exception or something like that.

Because of a change to QueryBuilder::createQuery is a major change, I don't think that It could be the solution, but it's a reflexion around this.

What do you think about that ?

Line 645 of https://github.com/doctrine/orm-documentation/blob/master/en/reference/dql-doctrine-query-language.rst

Best i can tell this has been re-named to Lexar::T_IDENTIFIER by looking at other functions in the distribution

After upgrading to 2.1.4 (from 2.1.2), the following dql started creating way more queries than necessary :
SELECT m, p, s, c, o
FROM FERMainBundle:Menu m
LEFT JOIN m.page p
LEFT JOIN m.section s
LEFT JOIN m.children c
LEFT JOIN s.position o
ORDER BY m.lft

Details to the code here:
http://pastie.textmate.org/private/z9gtgqe1odwenxcmudywqa
The model looks like that:
http://pastie.textmate.org/private/przxzfimsfyua02cxqcv9a

http://pastie.textmate.org/private/ob1jqiekv89e4xj9bq06q
First query is executed, it should in fact retrieve everything there is about the menu, but then it runs the second query for every menu element I have, generating a lot of queries that didn't occur before.

NamedQueries annotation doesn't work with just one NamedQuery

the problem is locale in the class Doctrine\ORM\Mapping\Driver\AnnotationDriver line 179.

Is needed validate if var $namedQueriesAnnot->value is an array before try perform foreach statement.

Please I'm sorry for my bad English.

Thank you

I wanted to use COALESCE in DQL with a function (e.g. CURRENT_TIMESTAMP()). If I run this DQL, I receive a syntax error exception like this one:

montbook:marlow mprebio$ php scripts/doctrine.php orm:run-dql "select COALESCE(CURRENT_TIMESTAMP()) from Project\Entity\User user"

[Doctrine\ORM\Query\QueryException]
[Syntax Error] line 0, col 33: Error: Expected Doctrine\ORM\Query\Lexer::T_CLOSE_PARENTHESIS, got '('

I've traced this error to Doctrine\ORM\Parser::ScalarExpression() which tries to interpret the current_timestamp function as a SimpleArithmeticExpression or as a StateFieldPathExpression (first if). As far as I understand this part of the parser, the function call should lead to the if part with $this->_isFunction(). Therefore I added a "and !$this->_isFunction()" to the first if clause. After this change everything works as expected: The above query returns the current timestamp (many times because of the from since DQL needs a from part).

Reordering the ifs should work too.

I have created a custom type called point but need a way to have a function called on columns of this type when fetching / updating / inserting entities.

For example:

Consider I have an entity which has a column called the_geom

This is associated with my custom type point

A basic select statement for this entity is as follows:

SELECT id, name, the_geom FROM points where id = 1

The problem is the_geom is encoded and on the PHP side I want it in human readable form. I would like a way to specify custom functions on SELECT / INSERT / UPDATE for columns of this custom type.

When selecting my entity I would like to execute the function ST_AsText(the_geom)

SELECT id, ST_AsText(the_geom) FROM points where id = 1

The same goes for updates and inserts. I would like to surround the column SQL with other custom functions, to encode my human readable text back to the encoded value for the DB.

Possibly this could be integrated into Doctrine\DBAL\Types\Type ?

// Modify the column SQL for insert
public function getSqlInsertColumn(....)

// Modify the column SQL for update
public function getSqlUpdateColumn(....)

// Modify the column SQL for select
public function getSqlSelectColumn(....)

// A possible example of getSqlSelectColumn(...)
public function getSqlSelectColumn($doctrineSql)
{
    // $doctrineSql == "p0_.the_geom"
    return 'ST_AsText(' . $doctrineSql . ')';
}

People use schema or many databases, however SQLite does not support the foo.bar syntax, so there is no way to run the tests in sqlite memory against these setups.

My entities

event
eveht.event_area_id=event_area.id (1:1)
event_area.event_id=event.id (1:1)
event_area.area.id=area.id (one area has many event_area's)
area.parent_id=area_id (hierarchial)
event.author_id=user.id (one user has many events)

area - STI: District/City/Region/Country/etc.

SELECT
	r, ra, a, ap, au, DATE(r.eventTime) AS event_date
FROM OloloEventsBundle:Event r
	LEFT JOIN r.eventArea ra
		LEFT JOIN ra.area a
			LEFT JOIN a.parent ap
	INNER JOIN r.author au WHERE r.eventTime <= :r_eventtime AND ra.area IN(:ra_area)
GROUP BY r
ORDER BY event_date DESC

This DQL caused an error "Cannot use object of type District as array in ORM\Internal\Hydration\ObjectHydrator.php on line 314". When I'm removing `ap` friom fetching - it works. Mapping are correct - there are many other places where it works correctly.

The Id Generators don't necessarily cast ids to integer values when generating them.

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/160

Added <variableDefault> on generated class.
This generate methods like:
```function setGroup(Group $group = null){
}
```

that allow to remove "Group" association if the relation is one-to-one.

Plus some indentation issue

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/158

Collapsed cascade elements, if cascade-all.
(better readability for generated xml)

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/169

For now, we have `@PrePersist`, `@PreUpdate` and `@PreRemove` callbacks. But it's not enough, cuz in some cases we need to run some entity method just before *every* `EntityManager#flush()` call (examples - translatable behavior and file uploading routines).

I've added and tested new `@PreFlush` event, which occurs during the start of the `EntityManager#flush()`, before any changeset gets calculated. This gives users ability to hook into flush process and prepare their entities to save even if they were not changed.

Pull-Request was automatically synchronized: https://github.com/doctrine/doctrine2/pull/175

added EntityRepository::getClassName() to fullfill the ObjectRepository interface

see https://github.com/doctrine/common/pull/70

Doctrine documentation states that a field default value is a string.
The annotation driver behaves so but the Yaml driver doesn't.

The Yaml driver requires that a field is set a type explicitly.

Why is this different among drivers and what is the actual default behaviour?

I have a query which is supposed to compare a result of a user defined function with a set of possible results
SELECT ... WHERE YEAR(w.date) IN (.......)

But I get the error:
[Syntax Error] line 0, col 49: Error: Expected Doctrine\ORM\Query\Lexer::T_IN, got '('

If I only compare the result of the function with a single value everything works as aspected:
SELECT ... WHERE YEAR(w.date) = 2011
.. works!

I also testet it with other functions like DATE_DIFF, etc. but always get the same error.

Some exception could/should be more precise (I've lost a lot of time figuring out why I was having an error)

When you have an id field inside a mapped-superclass, you get the following exception:

[ErrorException]
Notice: Undefined index: IdealTech\OnlineSystem\GeoBundle\Entity\AbsAddress in /Users/fmazerolle/Sites/it/os/vendor/doctrine/lib/Doctrine/ORM/Mapping/Driver/AbstractFileDriver.php line 121

The exception should be more verbose and tell the real cause of the error.

I have the following relations:

namespace Model;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass="Model\Repository\UserRepository")
 * @ORM\ChangeTrackingPolicy("DEFERRED_EXPLICIT")
 * @ORM\HasLifecycleCallbacks
 * @ORM\Table(name="users")
 */
class User
{
    /**
     * @ORM\OneToOne(targetEntity="Model\TwitterAccount", orphanRemoval=true, fetch="EAGER", cascade = {"persist"}, inversedBy="user")
     * @var TwitterAccount
     */
    private $twitterAccount;
}

/**
 * @ORM\Entity(repositoryClass = "Model\Repository\TwitterAccountRepository")
 * @ORM\Table(name = "twitter_accounts")
 * @ORM\ChangeTrackingPolicy("DEFERRED_EXPLICIT")
 */
class TwitterAccount
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\OneToOne(targetEntity="Model\User", fetch="EAGER")
     */
    private $user;
}

now when I add a new account, the user-side is not updated with the id of the account, but the account is still saved to the database.

$twitterAccount = new TwitterAccount();
$user->setTwitterAccount($twitterAccount);
$em->persist($user);
$em->flush();

The twitterAccount_id of the users table is empty, but the new account is added to the "twitter_accounts" table with the correct user_id.

Flushing at point #2 has no effect (outputs int(1)), flushing at point #1 works as expected (outputs int(5)).
this issue comes only when i trying to set boolean value on managed assotiated entity

upd. same issue with datetime properties

/**
 * @ORM\Entity
 */
class TestEntity
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;
    /**
     * @ORM\Column(type="integer")
     */
    protected $value;
    /**
     * @ORM\OneToOne(targetEntity="TestAdditionalEntity", inversedBy="entity", orphanRemoval="true", cascade={"persist", "remove"})
     */
    protected $additional;
}

/**
 * @ORM\Entity
 */
class TestAdditionalEntity
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;
    /**
     * @ORM\OneToOne(targetEntity="TestEntity", mappedBy="additional")
     */
    protected $entity;
    /**
     * @ORM\Column(type="boolean")
     */
    protected $bool;
    
    public function __construct()
    {
        $this->bool = false;
    }
}

$test = new \TestEntity();
$test->setValue(1);
$test->setAdditional(new \TestAdditionalEntity());

$em->persist($test);
$em->flush();
$em->clear();

$test = $em->getRepository('Bundle:TestEntity')->find(1);
$test->setValue(5);

// point #1
$test->getAdditional()->setBool(true);
// point #2

$em->flush();

var_dump($test->getValue());

It is

@return Doctrine\ORM\Persisters\AbstractEntityPersister

should be (I suppose)

@return \Doctrine\ORM\Persisters\BasicEntityPersister

or

@return Persisters\BasicEntityPersister

When using a sequence in Oracle as part of a composite key and the sequence is defined second, Doctrine retrieves from the sequence correctly but incorrectly assigns to the first key (which in this case is not the correct column)

Example:

/**
 * @Column(name="submission_id", type="integer")
 * @Id
 */
private $submissionId;

/**
 * @Column(name="model_id", type="integer")
 * @Id
 * @GeneratedValue(strategy="AUTO")
 * @SequenceGenerator(sequenceName="model_id_seq", initialValue=1, allocationSize=1)
 */
private $modelId;

Doctrine correctly retrieves the sequence, however it then attempts to set the first identifier field (in this case submission_id) instead of the sequence key.

The problem appears in /Doctrine/ORM/UnitOfWork.php line 613.
$class->indentifier is hard coded to item 0.

$this->entityIdentifiers[$oid] = array($class->identifier[0] => $idValue);

You can workaround this issue by defining the sequence first in the entity.

It might be a missing feature or I might be doing something wrong. I need to select an association (FK) without the need of a join.

I'm trying something like this:

select i.client.id , count(i) as total 
from \Invoice i 
GROUP BY i.client

But I get this error:
Error: Expected Doctrine\ORM\Query\Lexer::T_FROM, got '.'

ObjectHydrator has bug in hydrate entities with relation to entity of this same class throught reference entity. Example Model:

EntityA

• id
• title (string)
• entitiesB (annotation: @ORM\OneToMany(targetEntity="EntityB", mappedBy="entityAFrom"))

EntityB

• id
• entityAFrom (annotation: @ORM\ManyToOne(targetEntity="EntityA", inversedBy="entitiesB"))
• entityATo (annotation: @ORM\ManyToOne(targetEntity="EntityA"))
• type (string)

Scenario:

Execution of dql query 'SELECT a, b, ba FROM EntityA AS a LEFT JOIN a.entitiesB AS b LEFT JOIN b.entityATo AS ba' with max results set to "1" and data in database:

EntityATable:
id | title
1 | a
2 | b

EntityBTable:
id | entityAFromId | entityAToId | type
1 | 1 | 2 | type

Resume:

I expected collection of EntityA object (size=1 becouse I set max results to 1) with hydrated entitiesB collection (size=1 becouse in db is only 1 record) and hydrated entityTo object. entitiesB property of entityTo object should be empty PersistCollection (ready to lazy load) but is null...

I can provide TestCase for this issue.

Create postFlush event

For forward compatibility with https://gist.github.com/1034079 we want to add a "BaseEntity" into the core that handles boilerplate code through implementing "__call" and using the metadata to generate getter/setter/adder/is methods on the fly.

.

SimpleObject hydratation mode with inheritance, it appear that it's not working.

The problem start in SimpleObjectHydrator.php line 129 when calling UnitOfWork->createEntity(NULL, Array, Array).

I have a problem with saving many to many realtion. My entities are.

calss Entity1 {
		
	/**
	 * @Id @column
	 */
	protected $key1;

	/**
	 * @Id @column
	 */
	protected $key2;
	
	/**
	 * @ManyToMany (targetEntity="Entity2")
	 * @JoinTable (name="Entity1Entity2",
	 *      joinColumns={@JoinColumn(name="key1", referencedColumnName="key1")},
	 *      inverseJoinColumns={@JoinColumn(name="key3", referencedColumnName="key3")}
	 *      )
	 */
	protected $entity2;
}

class Entity2 {
	
	/**
	 * @Id @column
         * @GeneratedValue(strategy="AUTO")
	 */
	protected $key3
}

So in the middle table that i keep the keys from the other 2 i need to save only key1 and key3. And key2 need to be ignored.
But when i try to save instead of saving the proper values it try to save the value for key2 instead of the value of key1 in the middle table.
After some debuging i found that in Doctrine\ORM\Persisters\ManyToManyPersister in the private function _collectJoinTableColumnParameters lies the problem.
Instead of taking the key by the name you are doing array_pop. And you are making a check for composite keys but you presume that bouth of the keys will be
in the middle table, but that is not the case for me.
The quick fix that i did was to remove the current check for isComposite and get the keys like we are in the isComposite case always.

Tanks in advance for the great work.

Have a nice day!