To explain it simply, when you are loading an entity and if it has an association with one or more entities, what should doctrine do? 

If the association is marked as **EAGER**, it will fetch and load the associated entity as well.

If the association is marked as **LAZY**, doctrine will create proxy objects (dummy objects) in place of the actual entity. Only when you make the first call to that associated entity (like `$cart-&gt;getItems()`), doctrine will fetch and load that object(s) from database. (This is the [default Behaviour][1])

Refer: https://www.doctrine-project.org/projects/doctrine-orm/en/2.6/reference/advanced-configuration.html#association-proxies


  [1]: https://www.doctrine-project.org/projects/doctrine-orm/en/current/tutorials/extra-lazy-associations.html#extra-lazy-associations

Additional information about the difference between them:

`(fetch = &quot;EAGER&quot;)` 

the associated entities will be fetched as soon as the original query target entity is loaded from doctrine. That means there is no additional SQL query on DB.

`(fetch = &quot;LAZY&quot;)` 

the associated entities will be fetched ONLY IF the original query target entity calls the reference method, such as `$cart-&gt;getItems()`. That means, there is `additional` SQL query on DB.




I found CSS `will-change`&lt;sup&gt;[W3.org docs](http://dev.w3.org/csswg/css-will-change/), [MDN docs](https://developer.mozilla.org/en-US/docs/Web/CSS/will-change)&lt;/sup&gt; property (which already works in Chrome and is partiali supported by Firefox and Opera) but I&#39;m not really sure how it works.
Does anybody know something more about this mysterious thing?

I have just read that it allows browser to prepare for calculation over the element in the future.
I don&#39;t want to misunderstand it. So I have a few questions.

1. Should I add this property to the element class or its hover state?


        .my-class{
            will-change: &#39;opacity, transform&#39;
        }
        .my-class:hover{
            opacity: 0.5
        }
        .my-class:active{
            transform: rotate(5deg);
        }


   OR
       
        .my-class{
            ...
        }
        .my-class:hover{
            will-change: &#39;opacity&#39;
            opacity: 0.5
        }
        .my-class:active{
            will-change: &#39;transform&#39;
            transform: rotate(5deg);
        }

2. How can it increase a browser performance? Theoretically, when CSS is loaded, the browser already &quot;knows&quot; what will happen with each element, doesn&#39;t it?

If you can add any good example illustrating how to use it efficiently, I will be grateful :)

How to use and how works CSS&#39; will-change property?

This may be a duplicate, but I couldn&#39;t find the question anywhere, so I&#39;ll go ahead and ask:

Is there a simple way to delete a superuser from the terminal, perhaps analogous to Django&#39;s `createsuperuser` command?

Django delete superuser

What is the difference between `fetch=&quot;EAGER&quot;` and `fetch=&quot;LAZY&quot;` in annotation `@ManyToOne` in Doctrine ?

    /**
     * @ManyToOne(targetEntity=&quot;Cart&quot;, cascade={&quot;all&quot;}, fetch=&quot;EAGER&quot;)
     */
    
    /**
     * @ManyToOne(targetEntity=&quot;Cart&quot;, cascade={&quot;all&quot;}, fetch=&quot;LAZY&quot;)
     */

What is the difference between fetch=&quot;EAGER&quot; and fetch=&quot;LAZY&quot; in doctrine

What is the difference between <code>fetch="EAGER"</code> and <code>fetch="LAZY"</code> in annotation <code>@ManyToOne</code> in Doctrine ?
<pre><code class="hljs language-ini">/**
 * @ManyToOne(targetEntity="Cart", cascade={"all"}, fetch="EAGER")
 */

/**
 * @ManyToOne(targetEntity="Cart", cascade={"all"}, fetch="LAZY")
 */
</code></pre>

I have read about them through various resources. Importants ones are :-

 1. Wikipedia article about each of them
 2. https://stackoverflow.com/questions/9881611/whats-the-difference-between-jpa-and-hibernate

Here is my understanding about whats the  difference b/w them. I am not sure if i am right about JPA vs ORM

1. **ORM:** Object Relational Mapping is concept/process of converting the data from  Object oriented language to relational DB and vice versa
For example in   java its done with the help of reflection and jdbc.

2. **Hibernate:** Its the implementation of above concept.

3. **JPA:** Its the one step above ORM. Its high level API and specification so that different ORM tools can implement so that it provides
the flexibility to developer to change the implementation from one ORM to another (for example if application uses the JPA api and implementaion
is hibernate. In future it can switch to IBatis if required. But on the other if application directly lock the implementation with
Hibernate without JPA platform, switiching is going to be herculean task)

There can be ORM implementation with/without JPA specification.For example as per this [link][1] under hibernate section only 
Hibernate versions 3.2 and later provide an implementation for the Java Persistence API


  [1]: http://en.wikipedia.org/wiki/Java_Persistence_API#Hibernate

JPA vs ORM vs Hibernate?

I have a set of Sequelize models. I want to use migrations, not DB Sync.

[Sequelize CLI][1] seems to be able to do this, according to [this article][2]:
&quot;When you use the CLI for the model generation, you will gain the migration scripts for free as well.&quot;

How to auto generate the migrations with Sequelize CLI from existing Sequelize models?


  [1]: https://github.com/sequelize/cli
  [2]: http://sequelizejs.com/articles/express

How to auto generate migrations with Sequelize CLI from Sequelize models?

I want to make query in Laravel Eloquent like here its raw MySQL query 

    SELECT  * from  exampleTbl where id in(1,2,3,4)

I have tried this in Laravel Eloquent but it&#39;s not working 

    DB::where(&quot;id IN(23,25)&quot;)-&gt;get()


How to Make Laravel Eloquent &quot;IN&quot; Query?

In Django, custom managers are a great way to organize reusable query logic. The [Django documentation on **Custom managers**][1] says:

&gt; There are two reasons you might want to customize a `Manager`: to add extra `Manager` methods, and/or to modify the initial `QuerySet` the `Manager` returns.

However, [it goes on to describe][2] how custom `QuerySet` classes can also be created, and that these can be made accessible directly from the data model as a manager using `QuerySet.as_manager()`:

&gt; The `Manager` instance created by `QuerySet.as_manager()` will be virtually identical to the `PersonManager` from the previous example.

It seems like there is a lot of flexibility in how one could organize their logic between custom `Manager` and/or custom `QuerySet` classes. What are the principles by which I should decide when to use one versus the other?


  [1]: https://docs.djangoproject.com/en/3.0/topics/db/managers/#custom-managers
  [2]: https://docs.djangoproject.com/en/3.0/topics/db/managers/#creating-a-manager-with-queryset-methods

When should I use a custom Manager versus a custom QuerySet in Django?

I&#39;ve found the concept and meaning behind these methods to be a little confusing, is it possible for somebody to explain to me what the difference between `has` and `with` is, in the context of an example (if possible)?

Laravel - Eloquent &quot;Has&quot;, &quot;With&quot;, &quot;WhereHas&quot; - What do they mean?

I set up a parameter as array, as described in [http://jmsyst.com/libs/serializer/master/reference/annotations][1]

    class QuestionAnswer
    {
        /**
       * @JMS\Type(&quot;ArrayCollection&lt;Rest\Bundle\Entity\Fixture\QuestionOptions&gt;&quot;)
         * @Groups({&quot;QuestionAnswer&quot;})
       */
          public $question_options_array ;
    }

 and define some options in another class

    class QuestionOptions
    {
        /**
           * @JMS\Type(&quot;integer&quot;)
           * @Groups({&quot;get_option&quot;})
           */
          public $question_option_id ;
    
          /**
           * @JMS\Type(&quot;string&quot;)
           * @Groups({&quot;post_option&quot;})
           */
          public $question_option_description;
    }
In @ApiDoc I define 
    

         * input={
         *      &quot;class&quot; = &quot;Rest\BeautyBundle\Entity\Fixture\ProfileQuestionAnswer&quot;, 
         *      &quot;groups&quot;={&quot;QuestionAnswer&quot;, &quot;get_option&quot;},
         *  },
Before updating it works well. But after `composer update` only the &quot;QuestionAnswer&quot; group name works and it shows all properties from QuestionOptions class.
How can I submit properties in the array the way it was before the update?

  [1]: http://jmsyst.com/libs/serializer/master/reference/annotations

Group exclusion in Nelmio Api Doc does not work After updating composer

I&#39;m using Symfony 4.3.8 and I can&#39;t find any information about thoses deprecations :

&gt; User Deprecated: Creating Doctrine\ORM\Mapping\UnderscoreNamingStrategy without making it number aware is deprecated and will be removed in Doctrine ORM 3.0.
&gt; 
&gt; Creating Doctrine\ORM\Mapping\UnderscoreNamingStrategy without making it number aware is deprecated and will be removed in Doctrine ORM 3.0.

I searched in stacktrace and found this :

    class UnderscoreNamingStrategy implements NamingStrategy
    {
    private const DEFAULT_PATTERN      = &#39;/(?&lt;=[a-z])([A-Z])/&#39;;
    private const NUMBER_AWARE_PATTERN = &#39;/(?&lt;=[a-z0-9])([A-Z])/&#39;;

    /**
     * Underscore naming strategy construct.
     *
     * @param int $case CASE_LOWER | CASE_UPPER
     */
    public function __construct($case = CASE_LOWER, bool $numberAware = false)
    {
        if (! $numberAware) {
            @trigger_error(
                &#39;Creating &#39; . self::class . &#39; without making it number aware is deprecated and will be removed in Doctrine ORM 3.0.&#39;,
                E_USER_DEPRECATED
            );
        }

        $this-&gt;case    = $case;
        $this-&gt;pattern = $numberAware ? self::NUMBER_AWARE_PATTERN : self::DEFAULT_PATTERN;
    }

In this class, the constructor is always called without params, so $numberAware is always false.

This class is called in file which has been auto generated by the Symfony Dependency Injection, so I can&#39;t &quot;edit&quot; it ...

I thought maybe it was in doctrine.yaml :

    doctrine:
    orm:
        auto_generate_proxy_classes: true
        naming_strategy: doctrine.orm.naming_strategy.underscore
        auto_mapping: true
        mappings:
            App:
                is_bundle: false
                type: annotation
                dir: &#39;%kernel.project_dir%/src/Entity&#39;
                prefix: &#39;App\Entity&#39;
                alias: App

But I have not found any option to allow the number aware :(

Deprecation: Doctrine\ORM\Mapping\UnderscoreNamingStrategy without making it number aware is deprecated

I have updated my class definitions to make use of the newly introduced property type hints, like this:

```php
class Foo {
    
    private int $id;
    private ?string $val;
    private DateTimeInterface $createdAt;
    private ?DateTimeInterface $updatedAt;
    
    public function __construct(int $id) {
        $this-&gt;id = $id;
    }


    public function getId(): int { return $this-&gt;id; }
    public function getVal(): ?string { return $this-&gt;val; }
    public function getCreatedAt(): ?DateTimeInterface { return $this-&gt;createdAt; }
    public function getUpdatedAt(): ?DateTimeInterface { return $this-&gt;updatedAt; }
    
    public function setVal(?string $val) { $this-&gt;val = $val; }
    public function setCreatedAt(DateTimeInterface $date) { $this-&gt;createdAt = $date; }
    public function setUpdatedAt(DateTimeInterface $date) { $this-&gt;updatedAt = $date; }
}
```

But when trying to save my entity on Doctrine I am getting an error saying:

&gt; Typed property must not be accessed before initialization 

This not only happens with `$id` or `$createdAt`, but also happen with `$value` or `$updatedAt`, which are nullable properties.

Content Type	Original Author	Original Content on Stackoverflow
Question	Mohamed Ben HEnda	View Question on Stackoverflow
Solution 1 - Orm	Pradeep	View Answer on Stackoverflow
Solution 2 - Orm	vikbert	View Answer on Stackoverflow

What is the difference between fetch="EAGER" and fetch="LAZY" in doctrine

Orm Problem Overview

Orm Solutions

Solution 1 - Orm

Solution 2 - Orm

Django delete superuser

How to use and how works CSS' will-change property?

Attributions