Problème Many To One

Version imprimable

Bonjour à tous,

Je m'en remets à vous au sujet d'un problème de manipulation d'association avec Doctrine 2. Je vous explique la situation :

Je manipule des livres et des utilisateurs. Un livre appartient à un utilisateur et un utilisateur possède plusieurs livres.

En générant mes entités selon mon modèle de données, Doctrine me génère la relation Many To One sur ma clé étrangère Utilisateur dans mon entité Livre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 /** * Livre * * @Table(name="livre") * @Entity */ class Model_Entities_Livre { //... /** * @var User * * @ManyToOne(targetEntity="Model_Entities_User", cascade={"all"}) * @JoinColumns({ * @JoinColumn(name="user_user_id", referencedColumnName="user_id", unique=true) * }) */ private $_userUser; }
Mon problème est le suivant :
J'ai entré un nouvel utilisateur dans ma base afin de définir que tel livre lui appartient. Je le charge donc côté PHP afin de renseigner l'attribut utilisateur de mon objet livre. Seulement, quand j'insère dans la base mon objet livre, Doctrine m'oblige à persister mon objet User et ainsi, un nouvel utilisateur avec les mêmes attributs que celui déjà présent est inséré dans la table utilisateur. Y-a-t-il un moyen pour entrer un nouveau livre dans la base à partir d'un utilisateur déjà existant sans insérer un nouvel utilisateur ?

21/11/2011, 12h18
pc.bertineau

Peux-tu nous montrer le code qui gère la création de livre, il semble que c'est ici qu'il y a problème.

Entité Livre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
<?php
 
 
 
use Doctrine\ORM\Mapping as ORM;
 
/**
 * Livre
 *
 * @Table(name="livre")
 * @Entity
 */
class Model_Entities_Livre
{
    /**
     * @var integer $livreId
     *
     * @Column(name="livre_id", type="integer", nullable=false)
     * @Id
     * @GeneratedValue(strategy="IDENTITY")
     */
    private $_livreId;
 
    /**
     * @var string $livreName
     *
     * @Column(name="livre_name", type="string", length=45, nullable=true)
     */
    private $_livreName;
 
    /**
     * @var string $livreAuthor
     *
     * @Column(name="livre_author", type="string", length=45, nullable=true)
     */
    private $_livreAuthor;
 
    /**
     * @var string $livreEditeur
     *
     * @Column(name="livre_editeur", type="string", length=45, nullable=true)
     */
    private $_livreEditeur;
 
    /**
     * @var text $livreResume
     *
     * @Column(name="livre_resume", type="text", nullable=true)
     */
    private $_livreResume;
 
    /**
     * @var string $livreGenre
     *
     * @Column(name="livre_genre", type="string", length=45, nullable=true)
     */
    private $_livreGenre;
 
    /**
     * @var string $livreImage
     *
     * @Column(name="livre_image", type="string", length=100, nullable=true)
     */
    private $_livreImage;
 
    /**
     * @var User
     *
     * @ManyToMany(targetEntity="Model_Entities_User", inversedBy="empruntLivre")
     * @JoinTable(name="emprunt",
     *   joinColumns={
     *     @JoinColumn(name="emprunt_livre_id", referencedColumnName="livre_id")
     *   },
     *   inverseJoinColumns={
     *     @JoinColumn(name="emprunt_user_id", referencedColumnName="user_id")
     *   }
     * )
     */
    private $_empruntUser;
 
    /**
     * @var User
     *
     * @ManyToOne(targetEntity="Model_Entities_User", cascade={"persist"})
     * @JoinColumns({
     *   @JoinColumn(name="user_user_id", referencedColumnName="user_id", unique=true)
     * })
     */
    private $_userUser;
 
    public function __construct()
    {
        $this->_empruntUser = new \Doctrine\Common\Collections\ArrayCollection();
    }
 
	public function getId()
	{
		return $this->_livreId;
	}
 
	public function getName()
	{
		return $this->_livreName;
	}
 
	public function setName($vsName)
	{
		$this->_livreName = $vsName;
		return $this;
	}
 
	public function getAuthor()
	{
		return $this->_livreAuthor;
	}
 
	public function setAuthor($vsAuthor)
	{
		$this->_livreAuthor = $vsAuthor;
		return $this;
	}
 
	public function getEditeur()
	{
		return $this->_livreEditeur;
	}
 
	public function setEditeur($vsEditeur)
	{
		$this->_livreEditeur = $vsEditeur;
		return $this;
	}
 
	public function getResume()
	{
		return $this->_livreResume;
	}
 
	public function setResume($vsResume)
	{
		$this->_livreResume = $vsResume;
		return $this;
	}
 
	public function getGenre()
	{
		return $this->_livreGenre;
	}
 
	public function setGenre($vsGenre)
	{
		$this->_livreGenre = $vsGenre;
		return $this;
	}	
 
	public function getImage()
	{
		return $this->_livreImage;
	}
 
	public function setImage($vsImage)
	{
		$this->_livreImage = $vsImage;
		return $this;
	}
 
	public function getUser()
	{
		return $this->_userUser;
	}
 
	public function setUser(Model_Entities_User $vsUser)
	{
		$this->_userUser = $vsUser;
		return $this;
	}
}

Entité User :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
<?php
 
use Doctrine\ORM\Mapping as ORM;
 
/**
 * User
 *
 * @Table(name="user")
 * @Entity
 */
class Model_Entities_User
{
    /**
     * @var integer $userId
     *
     * @Column(name="user_id", type="integer", nullable=false)
     * @Id
     * @GeneratedValue(strategy="IDENTITY")
     */
    private $_userId;
 
    /**
     * @var string $userPseudo
     *
     * @Column(name="user_pseudo", type="string", length=45, nullable=true)
     */
    private $_userPseudo;
 
    /**
     * @var string $userName
     *
     * @Column(name="user_name", type="string", length=45, nullable=true)
     */
    private $_userName;
 
    /**
     * @var string $userFirstname
     *
     * @Column(name="user_firstname", type="string", length=45, nullable=true)
     */
    private $_userFirstname;
 
    /**
     * @var string $userMail
     *
     * @Column(name="user_mail", type="string", length=45, nullable=true)
     */
    private $_userMail;
 
    /**
     * @var string $userPassword
     *
     * @Column(name="user_password", type="string", length=45, nullable=true)
     */
    private $_userPassword;
 
    /**
     * @var Livre
     *
     * @ManyToMany(targetEntity="Model_Entities_Livre", mappedBy="empruntUser")
     */
    private $empruntLivre;
 
    public function __construct()
    {
        $this->empruntLivre = new \Doctrine\Common\Collections\ArrayCollection();
    }
 
	public function getId()
	{
		return $this->_userId;
	}
 
	public function getPseudo()
	{
		return $this->_userPseudo;
	}
 
	public function setPseudo($vsPseudo)
	{
		$this->_userPseudo = $vsPseudo;
		return $this;
	}
 
	public function getName()
	{
		return $this->_userName;
	}
 
	public function setName($vsName)
	{
		$this->_userName = $vsName;
		return $this;
	}
 
	public function getFirstname()
	{
		return $this->_userFirstname;
	}
 
	public function setFirstname($vsFirstname)
	{
		$this->_userFirstname = $vsFirstname;
		return $this;
	}
 
	public function getMail()
	{
		return $this->_userMail;
	}
 
	public function setMail($vsMail)
	{
		$this->_userMail = $vsMail;
		return $this;
	}
 
	public function getPassword()
	{
		return $this->_userPassword;
	}
 
	public function setPassword($vsPassword)
	{
		$this->_userPassword = $vsPassword;
		return $this;
	}
}

Appel :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
$livre = new Model_Livre();
	$user = new Model_User();
	$user->load(10);
	$livre->setName('twilight')
		  ->setAuthor('Stephanie Meyer')
		  ->setEditeur('Flamarion')
		  ->setResume('film Pourri')
		  ->setGenre('Epouvante')
		  ->setImage('chemin')
		  ->setUser($user)
		  ->save();

Je précise que je ne manipule pas directement les entités, je passe par deux modèles, Model_Livre et Model_User qui manipulent les entités. La méthode load($id) utilise la méthode find de l'entity manager avec l'id de l'entité manipulée et la méthode save utilise persist et flush pour l'insertion en base.
Le problème vient apparemment de l'instruction persist en cascade sur l'attribute $_userUser de l'entité Livre. Le souci est que sans cette précison, Doctrine me lève une erreur m'explicitant que l'entité user passé à cet attribut doit obligatoirement être persisté. Je ne sais vraiment que faire...

21/11/2011, 15h13
arnooo999
Bonjour,
C'est le code de Model_Livre et Model_User qui manque maintenant mais tu te compliques la vie en créant des classes supplémentaires.
Le code classique pour persister une entité est suffisament clair et concis
Code:

1 2 3 4 5 6 7 8 $em = EntityManager::create($dbParams, $config); $user=$em->find('Model_entities_Livre',10); $book=new Livre(); $book->setUser($user); //etc $em->persist($book); $em->flush();
21/11/2011, 15h20
gawel1
Il est tout à fait possible de partir de l'exemple d'arno :
Code:

1 2 3 4 5 6 7 8 9 $em = EntityManager::create($dbParams, $config); $user=$em->find('Model_entities_User',10); $book=new Livre(); $book->setUser($user); //etc $em->persist($book); $em->flush();
Le problème reste exactement le même. Après l'appel de la méthode Flush, Doctrine renvoie le message d'erreur suivant :

Citation:

Fatal error: Uncaught exception 'InvalidArgumentException' with message 'A new entity was found through the relationship 'Model_Entities_Livre#_userUser' that was not configured to cascade persist operations for entity: Model_Entities_User@000000004eca2364000000008ab3239b. Explicitly persist the new entity or configure cascading persist operations on the relationship. If you cannot find out which entity causes the problem implement 'Model_Entities_User#__toString()' to get a clue.' in C:\wampserver\www\ProjetDoctrine\libs\Doctrine\ORM\UnitOfWork.php on line 576

Ce problème est résolu par l'ajout de la propriété cascade="persist" sur l'attribut $_userUser. Le problème c'est qu'en ajoutant ce mot clé, un nouvel utilisateur est inséré dans la table User et la clé étrangère pointe sur ce nouvel utilisateur et non sur celui préalablement présent.

Le problème est donc comment arriver à insérer en base un livre sans persister l'utilisateur de ce livre si celui-ci est déjà présent dans la base ?

Que donne ce test?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
$em = EntityManager::create($dbParams, $config);
$user=$em->find('Model_entities_User',10);
$book=new Livre();
$book->setUser($user);
//etc
$em->persist($book);
 
echo "User id=", $user->getId();
if($em->contains($user)){
 echo 'User est managé';
}else{
 echo "User n'est pas managé";
}
 
echo "User dans Book id=", $book->getUser()->getId();
if($em->contains($book->getUser()){
 echo 'User dans Book est managé';
}else{
 echo "User dans Book n'est pas managé";
}
$em->flush();

21/11/2011, 15h59
gawel1

Citation:

User id=1User n'est pas managéUser dans Book id=1User dans Book n'est pas managé
( ! ) Fatal error: Uncaught exception 'InvalidArgumentException' with message 'A new entity was found through the relationship 'Model_Entities_Livre#_userUser' that was not configured to cascade persist operations for entity: Model_Entities_User@000000003358e43600000000fb38643c. Explicitly persist the new entity or configure cascading persist operations on the relationship. If you cannot find out which entity causes the problem implement 'Model_Entities_User#__toString()' to get a clue.' in C:\wampserver\www\ProjetDoctrine\libs\Doctrine\ORM\UnitOfWork.php on line 576

Je reprécise encore une fois que le mot clé cascade={"persist"} n'a pas été ajouté.
21/11/2011, 16h04
pc.bertineau

Pas de cascade dans ce sens, c'est bon comme ça.

Par contre, pourquoi mettre ta relation ManyToOne avec un attribut unique sur le joinColumn ?
=> Un User ne peut être le propriétaire que d'un seul livre ?
21/11/2011, 16h05
gawel1

Non c'est une erreur de ma part, un test non logique que j'ai effectué par désespoir :) .

Je l'ai enlevé depuis la mise en ligne de ce topic.
21/11/2011, 16h15
pc.bertineau

Ok...

Ton code semble correct. Pour ma part, je n'ai utilisé Doctrine2 qu'avec Symfony2 donc je ne saurai trop t'orienter. Si ce n'est qu'à chaque fois que j'ai eu des soucis de Proxies, et que ce n'était pas côté mapping, ça venait du cache qui n'était pas vidé... Tu as regardé de ce côté ?
21/11/2011, 16h18
gawel1

Oui j'ai regardé. Rien non plus...

Ce que je ne comprends pas c'est pourquoi Doctrine m'impose de persister mon utilisateur alors que celui-ci est déjà présent dans la base...

C'est incompréhensible
21/11/2011, 17h21
arnooo999
Je n'ai pas l'impression qu'il retrouve l'entité Utilisateur correctement puisqu'on lui demande de retrouver l'utilisateur d'id 10 et qu'il renvoit un utilisateur d'id 1.
implémente la méthode __toString dans User et teste ce code
Code:

1 2 3 4 5 $em = EntityManager::create($dbParams, $config); $user=$em->find('Model_entities_User',10); echo "\n",$user,"\n",get_class($user),"\n id=",$user->getId(),"\n"; //etc..
Est t'il possible dans ton code qu'il y ait deux entity Manager d'instanciés?
21/11/2011, 19h34
gawel1

En fait, c'est moi qui ait changé dans le programme la valeur du load car j'ai réinstallé ma base de données et ainsi, l'auto increment est reparti à 1 :D
21/11/2011, 19h53
gawel1

En réalité, je pense que la question à se poser est la suivante :
Quelle est la méthode pour insérer les données d'une entité avec une relation ManyToOne sans persister l'autre entité de la relation (en d'autre terme en utilisant des données déjà présentes dans la base sans les réinsérer une nouvelle fois)
21/11/2011, 20h51
arnooo999
La méthode à utiliser est bien celle décrite ci-dessus, j'utilise Doctrine2 avec Symfony2 mais je ne vois pas en quoi ce serait différent.

On récupère une entité depuis l'entity manager et on la passe à une nouvelle entité.
Le problème c'est que l'entityManager indique qu'il ne gère pas cette entité user

Code:

$em->contains($user)//false

donc il la considère comme une nouvelle entité et la recrée dans la base si l'annotation persist est ajoutée.
tu peux essayer comme cela peut-être
Code:

1 2 3 4 5 6 //.... $user=$em->merge($user);//rattache l'entité au contexte de persistence $book->setUser($user); $em->persist($book); $em->flush();
21/11/2011, 21h53
gawel1

Ca yest !!!! J'ai trouvé !!! En fait Arnoo avait raison il y avait bien deux instances différentes de l'entity manager. Dans le model Abstract, il suffisait de mettre l'entity Manager comme étant un attribut statique et ça fonctionne. C'est merveilleux !! Merci beaucoup
18/12/2014, 15h36
Kwadz

Bonjour,
Pourriez-vous présenter la partie du code corrigée ?
Merci