@ManyToOne et delete cascade

Version imprimable

24/06/2008, 11h26
Invité(e)

@ManyToOne et delete cascade
Bonjour,

j'ai fais le lien entre deux tables.
Une table taches
Une table Tachepriorite.

Une tache à une seule priorité
en revanche une priorité peut définir plusieurs taches.

voila pour le shéma.

table taches
[id]-[nom]-[prenom]-[libelle]-[date]-[idPriorite]
enregistrement
[1]-[bob]-[otool]-[test]-[2008-06-24]-[1]

table tachepriorite:
[idpriorite]-[type]
enregistrement
[1]-[urgent]

mon problème:

Le delete en cascade ne s'effectue pas lorsque je veux supprimer une priorité.
J'aurai aimé pouvoir supprimer en cascade toutes les taches dont la priorité disparait.

voici mon code:

mon entity tache
Code:

1 2 3 4 @ManyToOne(cascade = {CascadeType.ALL}) @JoinColumn(name="idPriorite" , nullable=false) private TachesPriorite refPriorite;
voici la requête sql correspondant à ma contrainte de clé étrangère générée automatiquement via JPA.
Code:

1 2 3 4 5 ALTER TABLE taches ADD CONSTRAINT fk94dc8fe08bf812e8 FOREIGN KEY (idpriorite) REFERENCES tachespriorite (idpriorite) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION;
normalement pour ma clé étrangère j'aurai du avoir ON DELETE CASCADE au lieu de ON DELETE NO ACTION.

mais apparement JPA n'a pas traduit ma contrainte via l'annotation @ManyToOne(cascade = {CascadeType.ALL})

quelqu'un aurait il une idée ?

ps: lorsque je modifie manuellement la contrainte de clé étrangère directement dans postgres ça fonctionne (normal me direz vous)

merci beaucoup!

en espérant que quelqu'un saura ou se trouve mon erreur.
25/06/2008, 10h53
Invité(e)

bonjour,

je galère pas mal ^^

quelqu'un pourrait il m'expliquer le principe pour faire ceci:

je voudrais avoir une liste taches (table 1)
chaque tache à une priorité (table 2)

je voudrais que lorsque je supprime une priorité, toute les taches soient supprimées en cascade.

je cherche je cherche mais n'y parvient toujours pas.

merci !
25/06/2008, 11h19
JeitEmgie

Citation:

Envoyé par amazoone

bonjour,

je galère pas mal ^^

quelqu'un pourrait il m'expliquer le principe pour faire ceci:

je voudrais avoir une liste taches (table 1)
chaque tache à une priorité (table 2)

je voudrais que lorsque je supprime une priorité, toute les taches soient supprimées en cascade.

je cherche je cherche mais n'y parvient toujours pas.

merci !

en JPA, vous mettez le CASCADE du côté de l'entité source de l'évènement…

si vous voulez d'une priorité effacée "cascade" sur les tâches qu'elle contient, vous mettez le CASCADE sur le OneToMany dans la priorité…
pas sur le ManyToOne de la tâche…

et ne vous préoccupez pas trop du code SQL "on update"; "on delete"…
les ORM ne peuvent pas toujours compter sur le RDBMS pour gérer les cascades de contraintes car il leur faut maintenir leurs caches à jour…
(avoir une entité effacée du repository à leur insu par le RDBMS mais avec la copie en cache toujours présente pourrait avoir des effets de bord catastrophiques sur l'intégrité des données…)

merci beaucoup, mais sur quel champ dois je le mettre ?
car j'avais déjà essayé cela mais sans résultat.

j'ai mis le @OneToMany(cascade = CascadeType.ALL) sur le id de la priorité mais rien n'y fait

voici ma tache:

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
 
package bean.entity;
 
import interfaces.entity.InterfaceTaches;
 
import java.io.Serializable;
import java.sql.Date;
 
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
 
@Entity(name="Taches")
@Table(name = "Taches")
 
@NamedQueries({
	@NamedQuery(name = "findByNom",       query = "select id from Taches where nom = ?1"),
	@NamedQuery(name = "findByPrenom",    query = "select id from Taches where prenom = ?1"),
	@NamedQuery(name = "findByDate",      query = "select id from Taches where date = ?1"),
	@NamedQuery(name = "findByPriorite",  query = "select id from Taches where priorite = ?1")
})
 
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public class Taches implements Serializable, InterfaceTaches {
 
 
	private static final long serialVersionUID = 3718006259932821939L;
 
 
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id", nullable = false)
    private int id;
 
    @Column(name = "nom")
    private String nom;
 
    @Column(name = "prenom")
    private String prenom;
 
    @Column(name = "commentaire")
    private String commentaire;
 
    @Column(name = "date")
    private Date date;
 
 
    @ManyToOne()
    @JoinColumn(name = "refPriorite", referencedColumnName = "idpriorite", nullable=false)
    private TachesPriorite refPriorite;
 
 
    public Taches(){
 
    }
 
	public Taches(String nom, String prenom, String commentaire,Date date) {
		super();
		this.nom = nom;
		this.prenom = prenom;
		this.commentaire = commentaire;
		this.date=date;
	}
 
 
	public int getId() {
		return id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	public String getNom() {
		return nom;
	}
 
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	public String getPrenom() {
		return prenom;
	}
 
	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}
 
	public String getCommentaire() {
		return commentaire;
	}
 
	public void setCommentaire(String commentaire) {
		this.commentaire = commentaire;
	}
 
	public Date getDate() {
		return date;
	}
 
	public void setDate(Date date) {
		this.date = date;
	}
 
 
	public TachesPriorite getRefPriorite() {
		return refPriorite;
	}
 
	public void setRefPriorite(TachesPriorite refPriorite) {
		this.refPriorite = refPriorite;
	}
 
}

et voici ma priorite:

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
 
package bean.entity;
 
import java.io.Serializable;
 
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
 
@Entity(name="TachesPriorite")
@Table(name = "TachesPriorite")
public class TachesPriorite implements Serializable{
 
	private static final long serialVersionUID = -5984983946191113541L;
 
	@Id
    @OneToMany(cascade = CascadeType.ALL)
    @Column(name = "idPriorite", nullable = false)
    private int idPriorite;
 
    @Column(name = "type")
    private String type;
 
 
	public TachesPriorite(int idPriorite, String type) {
		super();
		this.idPriorite = idPriorite;
		this.type = type;
	}
 
	public TachesPriorite() {}
 
	public int getId() {
		return idPriorite;
	}
 
	public void setId(int idPriorite) {
		this.idPriorite = idPriorite;
	}
 
	public String getType() {
		return type;
	}
 
	public void setType(String type) {
		this.type = type;
	}
 
	public int getIdPriorite() {
		return idPriorite;
	}
 
	public void setIdPriorite(int idPriorite) {
		this.idPriorite = idPriorite;
	}
}

et au final je me retrouve toujours avec cette erreur:

Code:

1
2
3
 
ERROR: update or delete on table "tachespriorite" violates foreign key constraint "fk94dc8fe03132c660" on table "taches"
  Détail : Key (idpriorite)=(1) is still referenced from table "taches".

il ne veut pas supprimer ma priorité car forcément il existe encore des références

25/06/2008, 11h55
JeitEmgie
Citation:
Envoyé par amazoone

et au final je me retrouve toujours avec cette erreur:

Code:

1 2 3 ERROR: update or delete on table "tachespriorite" violates foreign key constraint "fk94dc8fe03132c660" on table "taches" Détail : Key (idpriorite)=(1) is still referenced from table "taches".

il ne veut pas supprimer ma priorité car forcément il existe encore des références
et vous avez enlevez les contraintes RDBMS que vous aviez rajouté manuellement ?
25/06/2008, 12h03
Invité(e)

Citation:

et vous avez enlevez les contraintes RDBMS que vous aviez rajouté manuellement ?

vous voulez parler des modification manuelles directement dans le code sql de la base c'est ça ?

si c'est ça alors je confirme. Je ne touche plus au code sql de ma base, je laisse JPA s'occuper de ça.
26/06/2008, 10h08
Invité(e)
bonjour,

bon j'ai avancé ! ...dans le bon sens je ne sais pas ...

voila j'ai modifié les annotation du côté de mes Entity tache et tachepriorite.

voila le code de la Tache:
Code:

1 2 3 4 @ManyToOne() @JoinColumn(name = "refPriorite", referencedColumnName = "idpriorite", nullable=false) private TachesPriorite refPriorite;
et voila le code de TachesPriorite:
Code:

1 2 3 @OneToMany (fetch = FetchType.EAGER,cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE}) private Collection<Taches> tache;
cela m'a généré un nouveau shéma en base de données ! en effet une nouvelle table est apparue ! la table tachepriorite_tache.

la base de données:
http://img140.imageshack.us/img140/3636/tablelf4.png

cette table "tachepriorite_tache" fait le lien entre les tables tache et tachepriorite.

alors plusieurs remarques:
+ Si je cré une tache alors que la priorité n'existe pas: ça ne fonctionne pas -> résultat attendu

+ Si j'ajoute une tache tout se passe bien hormis le faite que la nouvelle table
"tachepriorite_tache" n'est pas mise à jour !

du coup la suppression en cascade ne peut fonctionner !

en clair il aurait fallu que lorsque j'ajoute une tache, la table "tachepriorite_tache" ajoute la liaison entre tache et tachepriorite.

j'ai testé manuelement et cela fonctionne, si j'ajoute le lien manuellement je peux par la suite faire la suppression en cascade.

questions:

+ comment faire pour qu'à l'ajout d'une tache, la table générée intitulée "tachepriorite_tache" soit mise à jour automatiquement ?
+ Est ce la bonne façon de procéder ?

quelqu'un à t-il une idée ?

merci beaucoup, je rame dur ^^ !

yess !

Bon et bien tout fonctionne .... pour le moment :lol:.

alors pour ceux qui auraient le même soucis que moi voila ce que j'ai fais en détail ;) (si quelqu'un sait comment faire d'une autre façon et mieux je suis preneur !!)

Ceci pourrait faire office de tuto ;) (à y penser ;) )
+------------------------------------------------------------------------+
+FAIRE UNE RELATION OneToMany / ManyToOne AVEC DELETE EN CASCADE +
+------------------------------------------------------------------------+

Le but étant de créer une sorte de petite todoliste. Nous aurons une tache (nom,prenom,commentaire,date,refPriorité) et une priorité (id,type)

Chaque tache que nous ajouterons devra avoir une priorité et celle ci devra exister. Auquel cas la tache ne sera pas enregistré en, base de données (persitée)

+Etape 1:
J'écris deux Entity
-Un entity tache
-Un Entity tachePriorite

+Etape 2
Je défini les relations
-OneToMany
-ManyToOne

+Etape 3
Je met en place un manager.

+------------------------------------+

Etape 1

code de l'Entity tache

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
 
package bean.entity;
 
import interfaces.entity.InterfaceTaches;
 
import java.io.Serializable;
import java.sql.Date;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
 
@Entity(name="Taches")
@Table(name = "Taches")
 
@NamedQueries({
	@NamedQuery(name = "findByNom",       query = "select id from Taches where nom = ?1"),
	@NamedQuery(name = "findByPrenom",    query = "select id from Taches where prenom = ?1"),
	@NamedQuery(name = "findByDate",      query = "select id from Taches where date = ?1"),
	@NamedQuery(name = "findByPriorite",  query = "select id from Taches where priorite = ?1")
})
 
public class Taches implements Serializable, InterfaceTaches {
 
 
	private static final long serialVersionUID = 3718006259932821939L;
 
 
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id", nullable = false)
    private int id;
 
    @Column(name = "nom")
    private String nom;
 
    @Column(name = "prenom")
    private String prenom;
 
    @Column(name = "commentaire")
    private String commentaire;
 
    @Column(name = "date")
    private Date date;
 
    @ManyToOne()
    @JoinColumn(name = "refPriorite", referencedColumnName = "idpriorite", nullable=false)
    private TachesPriorite refPriorite;
 
 
    public Taches(){
 
    }
 
	public Taches(String nom, String prenom, String commentaire,Date date) {
		super();
		this.nom = nom;
		this.prenom = prenom;
		this.commentaire = commentaire;
		this.date=date;
	}
 
 
	public int getId() {
		return id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	public String getNom() {
		return nom;
	}
 
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	public String getPrenom() {
		return prenom;
	}
 
	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}
 
	public String getCommentaire() {
		return commentaire;
	}
 
	public void setCommentaire(String commentaire) {
		this.commentaire = commentaire;
	}
 
	public Date getDate() {
		return date;
	}
 
	public void setDate(Date date) {
		this.date = date;
	}
 
 
	public TachesPriorite getRefPriorite() {
		return refPriorite;
	}
 
	public void setRefPriorite(TachesPriorite refPriorite) {
		this.refPriorite = refPriorite;
	}
 
}

code de l'Entity TachePriorite

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
 
package bean.entity;
 
import java.io.Serializable;
import java.util.Collection;
 
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
 
@Entity(name="TachesPriorite")
@Table(name = "TachesPriorite")
public class TachesPriorite implements Serializable{
 
	private static final long serialVersionUID = -5984983946191113541L;
 
	@Id
    @Column(name = "idPriorite", nullable = false)
    private int idPriorite;
 
    @Column(name = "type")
    private String type;
 
    @OneToMany (fetch = FetchType.LAZY,cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE})
    private Collection<Taches> tache;
 
	public TachesPriorite(int idPriorite, String type) {
		super();
		this.idPriorite = idPriorite;
		this.type = type;
	}
 
	public TachesPriorite() {}
 
	public int getId() {
		return idPriorite;
	}
 
	public void setId(int idPriorite) {
		this.idPriorite = idPriorite;
	}
 
	public String getType() {
		return type;
	}
 
	public void setType(String type) {
		this.type = type;
	}
 
	public int getIdPriorite() {
		return idPriorite;
	}
 
	public void setIdPriorite(int idPriorite) {
		this.idPriorite = idPriorite;
	}
 
	public Collection<Taches> getTache() {
		return tache;
	}
 
	public void setTache(Collection<Taches> tache) {
		this.tache = tache;
	}
 
}

Etape 2:

les annotations:

pour la tache :
+Notre tache à une et une seule priorité
+La priorité référencée doit exister dans la table tachespriorite

donc on ajoute ceci:

Code:

1
2
3
4
 
    @ManyToOne()
    @JoinColumn(name = "refPriorite", referencedColumnName = "idpriorite", nullable=false)
    private TachesPriorite refPriorite;

pour la tachepriorite:
+Une priorité à un identifiant unique et un type
+Elle référence une ou plusieurs taches
+La suppression d'une priorité supprime les taches associées en cascade

Code:

1
2
3
 
    @OneToMany (fetch = FetchType.LAZY,cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE})
    private Collection<Taches> tache;

on référence donc ici dans le cas d'un OneToMany une Collection de tache !

NB: penser à mettre en place les getter et setter pour ces champs !

Etape 3

mise en place d'un manager. Pour ma part j'ai procédé de cette façon. Chaque Entity possède un manager qui se charge de gérer la persistance des données.

Le manager implémente donc un EntityManager que je récupère par injection comme suit:

NB: ce manager contient beaucoup de méthodes mais elles ne sont pas toutes obligatoire ! libre à vous d'implémenter vos propres méthodes ;)

J'ai dans ce cas ci imaginer une multitude de méthodes de recherches.

J'ai mis en place les principales méthodes du CRUD (create,refresh,update, et delete)

Pour la création d'une tache:
On crée une nouvelle instance de l'Entity Tache (c'est un simple POJO)
puis on fait un persist de cette Tache grace à l'EntityMAnager

Pour L'update:
Il suffit de récupérer la Tache via le manager en faisant un find
puis un set sur la Tache récupérée avec les valeurs souhaitées

Pour le delete
Il faut faire un remove par le biais du manager

voila je vous laisse regarder le code ;) ça vous parlera peut être plus !

Merci pour l'aide que tu m'as apporté JeitEmgie

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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
 
package bean.session.manager;
 
import java.sql.Date;
import java.util.Collection;
import java.util.List;
 
import interfaces.session.InterfaceTachesManager;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
 
import bean.entity.Taches;
import bean.entity.TachesPriorite;
 
 
@Stateless(mappedName="TachesManager")
@Remote(InterfaceTachesManager.class)
public class TachesManager implements InterfaceTachesManager{
 
	/*
	 * http://java.sun.com/developer/technicalArticles/J2EE/jpa/#tents
	 * the @PersistenceContext annotation injects an EntityManager with 
	 * a transactional persistence context, on which the session bean has a dependency
	 */
	@PersistenceContext(unitName="ToDoEJB3")
	private EntityManager entityManager;
 
 
    /*
     * METHODES DU CRUD
     * 
     */
 
	/*
	 * CREATION
	 * 
	 * Pour définir une priorité cela se fait simplement:
	 * 1- On défini dans l'entity à @joinColumn
	 * 2- Pour ce joinColumn on défini un getter et un setter
	 * 3- Enfin dans le manager au moment de la création d'une tache, on fait un new de notre tache puis un setRefPriorite
	 * 4- Ainsi on a pas besoin de définir au constructeur de tache la priorité
	 * on passe uniquement l'objet lié et JPA fait le reste.
	 */
 
    public void create(String nom, String prenom, String commentaire,Date date,int priorite) {
 
    	long begin = System.currentTimeMillis();
 
    	if(priorite!=0){
 
    		Taches tache = new Taches(nom,prenom,commentaire, date);
    		try{
		    	tache.setRefPriorite(entityManager.find(TachesPriorite.class, priorite));
		    	entityManager.persist(tache);
 
 
		    	TachesPriorite tachepriorite = (TachesPriorite)entityManager.find(TachesPriorite.class, priorite);
		    	Collection<Taches> collect = tachepriorite.getTache();
		    	collect.add(tache);
		    	tachepriorite.setTache(collect);
 
 
		    	entityManager.persist(tachepriorite);
 
		    	//entityManager.find(TachesPriorite.class, priorite).setTache(collect);
 
 
		    	System.out.println("Tache créée. nom:"+nom+" prenom:"+prenom+" commentaire:"+commentaire+" date:"+date);    	
		    }
    		catch(Exception a){
 
    			try{
    				entityManager.remove(tache);
    				System.out.println("rollback effectuée, tache supprimée");
    			}
    			catch(Exception i){
    				System.out.println("priorité inexistante ou null");
    				System.out.println("priorité : "+priorite);
    				System.out.println("La tache n'a pas été crée donc pas besoin de rollback");
    			}
    			a.printStackTrace();
    		}
 
    	}
    	else{
    		System.out.println("Veuillez entrer une priorité");
    	}
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[CREATE]Temps d execution :"+time +"ms");
    }
 
    /*
     * REFRESH
     * permet de réinitialiser l’état d’un objet par rapport à la base de données (annule toute modification)
     */
 
    public void undoUpdate(int id){
    	long begin = System.currentTimeMillis();
 
    	entityManager.refresh(entityManager.find(Taches.class, id));
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[undoUpdate]Temps d execution :"+time +"ms");
    }
 
    //UPDATE
    public void updateNom(int id,String nom) {
    	long begin = System.currentTimeMillis();
 
    	entityManager.find(Taches.class, id).setNom(nom);
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[updateNom]Temps d execution :"+time +"ms");
    }
 
    public void updatePrenom(int id,String prenom) {
    	long begin = System.currentTimeMillis();
 
    	entityManager.find(Taches.class, id).setPrenom(prenom);
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[updatePrenom]Temps d execution :"+time +"ms");
    }
 
    public void updateCommentaire(int id,String commentaire) {
    	long begin = System.currentTimeMillis();
 
    	entityManager.find(Taches.class, id).setCommentaire(commentaire);
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[updateCommentaire]Temps d execution :"+time +"ms");
    }
 
    public void updateDate(int id,Date date) {
    	long begin = System.currentTimeMillis();
 
    	entityManager.find(Taches.class, id).setDate(date);
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[updateDate]Temps d execution :"+time +"ms");
    }
 
 
    //DELETE
    public void delete(int id) {
    	long begin = System.currentTimeMillis();
 
    	entityManager.remove(entityManager.find(Taches.class, id));
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[delete]Temps d execution :"+time +"ms");
     }
 
    @SuppressWarnings("unchecked")
	public void deleteByName(String nom) {
    	long begin = System.currentTimeMillis();
 
	     List liste = rechercherTachesByNom(nom);
	     for(int j=0;j<liste.size();j++){
	    	 entityManager.remove(entityManager.find(Taches.class,Integer.parseInt(liste.get(j).toString())));
	     }
 
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[delete]Temps d execution :"+time +"ms");
     }
 
    /*
     * METHODES DE RECHERCHE
     * @return List
     * 
     */
 
    //LISTE COMPLETE DES TACHES
	@SuppressWarnings("unchecked")
	public List getListTaches() {
    	long begin = System.currentTimeMillis();
 
		Query oQuery = entityManager.createQuery("select id from Taches");
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[getListTaches]Temps d execution :"+time +"ms");
 
		return oQuery.getResultList();
	}
 
	//LISTE DES TACHE PAR ID
	public Taches rechercherTachesById(int id) {
    	long begin = System.currentTimeMillis();
 
    	Taches tache = entityManager.find(Taches.class, id);
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[rechercherTachesById]Temps d execution :"+time +"ms");
 
		return tache;
	}
 
	//LISTE DES TACHES PAR NOM
	@SuppressWarnings("unchecked")
	public List rechercherTachesByNom(String nom){
    	long begin = System.currentTimeMillis();
 
    	Query query = entityManager.createNamedQuery("findByNom");
        query.setParameter(1, nom);
        List liste = query.getResultList();
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[rechercherTachesByNom]Temps d execution :"+time +"ms");
 
        return liste; 
    }
 
	//LISTE DES TACHES PAR PRENOM
	@SuppressWarnings("unchecked")
	public List rechercherTachesByPrenom(String prenom){
    	long begin = System.currentTimeMillis();
 
    	Query query = entityManager.createNamedQuery("findByPrenom");
        query.setParameter(1, prenom);
        List liste = query.getResultList();
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[rechercherTachesByPrenom]Temps d execution :"+time +"ms");
 
        return liste;  
    }
 
	//LISTE DES TACHES PAR DATE
	@SuppressWarnings("unchecked")
	public List rechercherTachesByDate(Date date){
    	long begin = System.currentTimeMillis();
 
    	Query query = entityManager.createNamedQuery("findByDate");
        query.setParameter(1, date);
        List liste = query.getResultList();
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[rechercherTachesByDate]Temps d execution :"+time +"ms");
 
        return liste;  
    }
 
	//LISTE DES TACHES PAR DATE
	@SuppressWarnings("unchecked")
	public List rechercherTachesByPriorite(int priorite){
    	long begin = System.currentTimeMillis();
 
    	Query query = entityManager.createNamedQuery("findByPriorite");
        query.setParameter(1, priorite);
        List liste = query.getResultList();
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[rechercherTachesByPriorite]Temps d execution :"+time +"ms");
 
        return liste;
    }
 
	/*
	 * GETTER AND SETTERS
	 * @return un champ
	 */
 
	public String rechercherCommentaire(int id) {
 
		return entityManager.find(Taches.class, id).getCommentaire();
	}
 
	public Date rechercherDate(int id) {
 
		return entityManager.find(Taches.class, id).getDate();
	}
 
	public String rechercherNom(int id) {
 
		return entityManager.find(Taches.class, id).getNom();
	}
 
	public String rechercherPrenom(int id) {
 
		return entityManager.find(Taches.class, id).getPrenom();
	}
 
	public String rechercherPriorite(int id) {
		return entityManager.find(Taches.class, id).getRefPriorite().getType();
	}
 
	public int rechercherTotalTache() {
 
		return getListTaches().size();
	}
 
 
 
}

Résultat en base de données. Les tables sont toutes crées automatiquement

http://img140.imageshack.us/img140/3636/tablelf4.png

IMPORTANT:

Pour faire le delete en cascade la table intitulée tachepriorite_tache doit être rempli au moment ou l'on ajoute une tache en base de données ! sinon la suppression d'une priorité échouera automatiquement.

pour se faire lorsque l'on ajoute une tache, il faut juste apres ajouter la référence dans cette table !

souvenez vous, la tachepriorite référence une collection de taches ! donc ajouter une tache revient à ajouter une référence de la tache dans la collection de la tachepriorité (je suis clair ? :aie: )

et donc il faut faire comme suit lors de la création !

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
 
public void create(String nom, String prenom, String commentaire,Date date,int priorite) {
 
    	long begin = System.currentTimeMillis();
 
    	if(priorite!=0){
 
                //Je crée une nouvelle tache
    		Taches tache = new Taches(nom,prenom,commentaire, date);
    		try{
 
                     //je défini la priorité   	      
                     tache.setRefPriorite(entityManager.find(TachesPriorite.class, priorite));
 
                       //j'enregistre en base de données la nouvelle tache
                       entityManager.persist(tache);
 
	    	        //je récupère la tachepriorite associé à ma tache
		    	TachesPriorite tachepriorite = (TachesPriorite)entityManager.find(TachesPriorite.class, priorite);
 
                        //je récupère la collection de tache associée à cette tachepriorite
		    	Collection<Taches> collect = tachepriorite.getTache();
                        //puis j'ajoute ma nouvelle tache à cette collection
		    	collect.add(tache);
		    	tachepriorite.setTache(collect);
		    	 //et enfin je persiste le tout
		    	entityManager.persist(tachepriorite);	    	
 
		    	System.out.println("Tache créée. nom:"+nom+" prenom:"+prenom+" commentaire:"+commentaire+" date:"+date);    	
		    }
    		catch(Exception a){
 
    			try{
    				entityManager.remove(tache);
    				System.out.println("rollback effectuée, tache supprimée");
    			}
    			catch(Exception i){
    				System.out.println("priorité inexistante ou null");
    				System.out.println("priorité : "+priorite);
    				System.out.println("La tache n'a pas été crée donc pas besoin de rollback");
    			}
    			a.printStackTrace();
    		}
 
    	}
    	else{
    		System.out.println("Veuillez entrer une priorité");
    	}
 
    	long end = System.currentTimeMillis();
    	float time = ((float) (end-begin)) / 1000f;
    	System.out.println("[CREATE]Temps d execution :"+time +"ms");
    }

Ce n 'est qu'un exemple, je ne prétend rien et cherche à aider ;) donc si vous pouvez faire mieux faites suivre ;) !!