Doctrine2 ORM does not save changes to a DateTime field

by

The DateTime instances returned by ExampleBundle\Entity\User#getServiceExpiresAt() are the same objects stored in the entity itself, which breaks encapsulation.

The UnitOfWork in Doctrine ORM applies strict comparison for changesets, which basically means that in the case of properties of entities containing objects, if the object instance hasn’t changed, the ORM does not detect a change.

In strict comparison, following is true:

$dateTime1 = new \DateTime('@0');
$dateTime2 = new \DateTime('@0');
$dateTime3 = $dateTime1;

var_dump($dateTime1 !== $dateTime2); // true
var_dump($dateTime1 === $dateTime3); // true

$dateTime1->modify('+1 day');

var_dump($dateTime1 === $dateTime3); // true

This is a very common mistake among newcomers in OOP programming, and it can be solved quickly by fixing your getters and setters so that the original instance is never shared outside of your object, like in following example:

public function getServiceExpiresAt()
{
    return clone $this->service_expires_at;
}

public function setServiceExpiresAt(\DateTime $service_expires_at)
{
    $this->service_expires_at = clone $service_expires_at;
}

This will also fix your problem with Doctrine ORM.

Also, please note that this fixes possible leaks in your logic. For example, following code is buggy and hard to debug (when applying your currently broken getters/setters):

$bankTransaction1 = $someService->getTransaction(1);
$bankTransaction2 = $someService->getTransaction(2);

// leak! Now both objects reference the same DateTime instance!
$bankTransaction2->setDateTime($bankTransaction1->getDateTime());

// bug! now both your objects were modified!
$bankTransaction1->getDateTime()->modify('+1 day');

So, regardless of the ORM part in the question, please don’t break encapsulation.

More Related Contents:

  1. Why encapsulation is known as Data Hiding? [closed]
  2. Difference between abstraction and encapsulation?
  3. Simple way to understand Encapsulation and Abstraction
  4. Why “private” methods in the object oriented?
  5. Why encapsulation is an important feature of OOP languages? [closed]
  6. Difference between Encapsulation and Abstraction
  7. Why doesn’t Rust support trait object upcasting?
  8. Inheritance vs. Aggregation [closed]
  9. Constructors vs Factory Methods [closed]
  10. Why would I want to use Interfaces? [closed]
  11. When should one use interfaces?
  12. What is the difference between an abstract method and a virtual method?
  13. What is the rationale behind having companion objects in Scala?
  14. What is the difference between aggregation, composition and dependency? [duplicate]
  15. Do write-only properties have practical applications?
  16. R and object oriented programming
  17. is it possible to call overridden method from parent struct in Golang?
  18. DDD – the rule that Entities can’t access Repositories directly
  19. When to use interfaces or abstract classes? When to use both?
  20. Are Polymorphism , Overloading and Overriding similar concepts? [closed]
  21. “public” or “private” attribute in Python ? What is the best way?
  22. When to implement an interface and when to extend a superclass?
  23. Mixin vs inheritance
  24. Does the Single Responsibility Principle work in OOP?
  25. What does ‘low in coupling and high in cohesion’ mean
  26. Learning/Implementing Design Patterns (For Newbies) [closed]
  27. In SOLID, what is the distinction between SRP and ISP? (Single Responsibility Principle and Interface Segregation Principle)
  28. When to use a Class in VBA?
  29. VBA: how to test for object equality (whether two variables reference the same object)
  30. Overloading functions

Leave a Comment