What is the best practice regarding calling flush() method of Doctrine?

[iliayatsenko]

In Doctrine ORM there is a separation between persist() and flush() operations. Looks like whenever you want to insert/update your entity, you have to call two methods one by one. And most developers do it this way. But I wonder if it was intended to be used this way.

Most of the time I see repositories like this:

class EntityRepo extends ServiceEntityRepository
{
    public function save(Entity $entity): void
    {
        $this->getEntityManager()->persist($entity);
        $this->getEntityManager()->flush();
    }
}

And this approach has a big flaw, even if leave verbosity aside - call to flush() will sync ALL the not-synced entities with database, not only the one we are saving now. I would suggest to call

$this->getEntityManager()->flush($entity);

to restrict sync to only one entity, but this approach was deprecated by Doctrine.

In my understanding, flush() was intended to be called only once in "business transaction", and it's responsibility is to sync all the in-memory changes with database. And this adheres well to the "functional" idea of making domain core "pure" of any side effects: we just move all side effects outside the domain code. Am I wrong? What drawbacks has this approach?

What is the best practice of dealing with flush()?

[Fedik]

I would say, "Other".
To avoid of syncing ALL the not-synced entities with database, can do following:

• add attribute change-tracking-policy="DEFERRED_EXPLICIT" to your entity mapping https://www.doctrine-project.org/projects/doctrine-orm/en/2.16/reference/change-tracking-policies.html#deferred-explicit
• call persist($entity) then call flush()

The DEFERRED_EXPLICIT teels to flush entities that have been explicitly marked for change through persist($entity). Other will be ignored.

For multiple you can flush multiple as following:

foreach($changedEntities as $entity) {
  $em->persist($entity);
}
$em->flush(); // Will flush only marked through `persist($entity)`.

(Of course, need to consider amount and performance)

[iliayatsenko]

@Fedik, thanks, I've read your comment about this approach in one of Doctrine issues) It should work, but feels more like a workaround. And I had no doubt that a workaround exist. What I asked about is what was the intended way of using this Doctrine feature? If this was it, why didn't Doctrine make DEFERRED_EXPLICIT the default change tracking policy?

I would like to hear Doctrine maintainers about what they think was the intention of such separation? Only to optimize bulk operations when you can persist in a loop and then flush once? Or something more?