Qual é a diferença entre inversedBy e mappedBy?

Estou desenvolvendo meu aplicativo usando Zend Framework 2 e Doctrine 2.

Enquanto escrevo anotações, não consigo entender a diferença entre mappedBy e inversedBy.

Quando devo usar mappedBy ?

Quando devo usar inversedBy ?

Quando devo usar nenhum dos dois?

Aqui está um exemplo:

 /**
 *
 * @ORM\OneToOne(targetEntity="\custMod\Entity\Person", mappedBy="customer")
 * @ORM\JoinColumn(name="personID", referencedColumnName="id")
 */
protected $person;

/**
 *
 * @ORM\OneToOne(targetEntity="\Auth\Entity\User")
 * @ORM\JoinColumn(name="userID", referencedColumnName="id")
 */
protected $user;

/**
 *
 * @ORM\ManyToOne (targetEntity="\custMod\Entity\Company", inversedBy="customer")
 * @ORM\JoinColumn (name="companyID", referencedColumnName="id")
 */
protected $company;

Fiz uma pesquisa rápida e encontrei o seguinte, mas ainda estou confuso:

• Exemplo 1
• exemplo 2
• exemplo 3

• mappedBy deve ser especificado no lado inverso de uma associação (bidirecional)
• inversedBy deve ser especificado no lado proprietário de uma associação (bidirecional)

da documentação da doutrina:

• ManyToOne é sempre o lado proprietário de uma associação bidirecional.
• OneToMany é sempre o lado inverso de uma associação bidirecional.
• O lado proprietário de uma associação OneToOne é a entidade com a tabela que contém a chave estrangeira.

Veja https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/unitofwork-associations.html

As respostas acima não foram suficientes para eu entender o que estava acontecendo, então, depois de me aprofundar mais, acho que tenho uma maneira de explicar que fará sentido para as pessoas que lutaram como eu entender.

inversedBy e mappedBy são usados ​​pelo mecanismo INTERNAL DOCTRINE para reduzir o número de consultas SQL necessárias para obter as informações de que você precisa. Para ficar claro, se você não adicionar inversedBy ou mappedBy, seu código ainda funcionará, mas não será otimizado .

Então, por exemplo, veja as classes abaixo:

class Task
{
    /**
     * @var int
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @var string
     *
     * @ORM\Column(name="task", type="string", length=255)
     */
    private $task;

    /**
     * @var \DateTime
     *
     * @ORM\Column(name="dueDate", type="datetime")
     */
    private $dueDate;

    /**
     * @ORM\ManyToOne(targetEntity="Category", inversedBy="tasks", cascade={"persist"})
     * @ORM\JoinColumn(name="category_id", referencedColumnName="id")
     */
    protected $category;
}

class Category
{
    /**
     * @var int
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @var string
     *
     * @ORM\Column(name="name", type="string", length=255)
     */
    private $name;

    /**
     * @ORM\OneToMany(targetEntity="Task", mappedBy="category")
     */
    protected $tasks;
}

Essas classes, se você executar o comando para gerar o esquema (por exemplo, bin/console doctrine:schema:update --force --dump-sql), notará que a tabela Categoria não possui uma coluna para tarefas. (isso ocorre porque ele não tem uma anotação de coluna nele)

O importante a entender aqui é que as tarefas variáveis ​​estão lá apenas para que o mecanismo de doutrina interno possa usar a referência acima dela que diz sua categoria mappedBy. Agora ... não se confunda aqui como eu estava ... Categoria NÃO está se referindo ao NOME DA CLASSE , está se referindo à propriedade na classe Task chamada 'categoria $ protegida'.

Da mesma forma, na classe Tasks a propriedade $ category menciona que é inversedBy = "tasks", observe que isso é plural, NÃO É O PLURAL DO NOME DA CLASSE , mas apenas porque a propriedade é chamada de 'protected $ tasks' na categoria classe.

Depois de entender isso, torna-se muito fácil entender o que inversedBy e mappedBy estão fazendo e como usá-los nessa situação.

O lado que está referenciando a chave estrangeira como 'tarefas' no meu exemplo sempre obtém o atributo inversedBy porque precisa saber qual classe (por meio do comando targetEntity) e qual variável (inversedBy =) nessa classe 'trabalhar para trás' para fale e obtenha as informações da categoria. Uma maneira fácil de lembrar isso é que a classe que teria o Foreignkey_id é aquela que precisa ter inversedBy.

Onde, como acontece com a categoria, e sua propriedade $ tasks (que não está na mesa, lembre-se, apenas parte da classe para fins de otimização) é MappedBy 'tarefas', isso cria o relacionamento oficialmente entre as duas entidades para que a doutrina agora possa com segurança use instruções SQL JOIN em vez de duas instruções SELECT separadas. Sem mappedBy, o mecanismo de doutrina não saberia a partir da instrução JOIN, ele criará qual variável na classe 'Tarefa' para colocar as informações da categoria.

Espero que isso explique um pouco melhor.

No relacionamento bidirecional tem um lado proprietário e um lado inverso

mappedBy : colocado no lado inverso de um relacionamento bidirecional Para se referir ao seu lado proprietário

inversedBy : colocado no lado proprietário de uma relação bidirecional Para se referir ao seu lado inverso

E

mappedByAtributo usado com a declaração de mapeamento OneToOne, OneToMany ou ManyToMany.

Atributo inversedBy usado com a declaração de mapeamento OneToOne, ManyToOne ou ManyToMany.

Aviso : o lado proprietário de um relacionamento bidirecional, o lado que contém a chave estrangeira.

há duas referências sobre inversedBy e mappedBy na Documentação do Doctrine: Primeiro Link , Segundo Link

5.9.1. Possuir e lado inverso

Para associações muitos para muitos, você pode escolher qual entidade é proprietária e qual é o lado inverso. Existe uma regra semântica muito simples para decidir qual lado é mais adequado para ser o lado proprietário da perspectiva dos desenvolvedores. Você só precisa se perguntar qual entidade é responsável pelo gerenciamento da conexão e escolher isso como o lado proprietário.

Tome um exemplo de duas entidades Artigo e Tag. Sempre que você deseja conectar um Artigo a uma Tag e vice-versa, é principalmente o Artigo o responsável por esta relação. Sempre que você adiciona um novo artigo, deseja conectá-lo a tags existentes ou novas. Seu formulário de criação de artigo provavelmente apoiará essa noção e permitirá especificar as tags diretamente. É por isso que você deve escolher o Artigo como lado proprietário, pois torna o código mais compreensível:

http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/association-mapping.html