Bonjour,

Pour des questions de performance je voudrais savoir comment faire pour indexer une colonne objet dans un entity, voici l'entity avec uniquement l'attribut sur lequel je voudrais poser un index :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
@Table(
        uniqueConstraints = { @UniqueConstraint(columnNames = { "source", "cle" }) }
)
public abstract class APersonne extends AbstractEntity {
...
 
/** Clé de jointure, identifiant unique généré par les différentes sources, 
     * mais unique uniquement pour le périmètre de la source.*/
    @Embedded
    @Column(unique = true, nullable = false)
    private CleJointure cleJointure;
 
...
}
Et voici les différentes classes héritées.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@MappedSuperclass
public abstract class AbstractEntity extends AbstractSimpleEntity implements Serializable {
 
	//Attributs
	/** Gestion des versions de l'objet, incrémentation de +1 à chaque modification de update ou merge. */
	@Version
	private long version;
	/** Création automatique de la date de création de l'objet lors de la construction. */
	@Temporal(TemporalType.TIMESTAMP)
	private Date dateCreation;
	/** Donne l'information de la date de modification de l'objet. */
	@Temporal(TemporalType.TIMESTAMP)
	private Date dateModification;
	/** Donne l'information de la date d'acquittement de l'objet lors de l'export. */
    @Temporal(TemporalType.TIMESTAMP)
    private Date dateAcquittement;
 
...
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
@MappedSuperclass
public abstract class AbstractSimpleEntity implements Serializable {
 
	//Attributs
	/** Id de l'objet géré de façon automatique avec clé généré 
         * si non renseigné lors du persist. */
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private long id;
 
 
	//Constructeur
	/**
         * Constructeur de l'objet AbstractEntity.java.
         */
	public AbstractSimpleEntity() {
		//TODO vide
	}
 
	//Accesseurs	
	/**
         * Getter du membre id.
         * @return <code>long</code> le membre id
         */
	public long getId() {
		return this.id;
	}
	/**
         * Setter du membre id.
         * @param id la nouvelle valeur du membre id  
         */
	public void setId(final long id) {
		this.id = id;
	}
 
	/**
         * Transforme cette instance en chaine de caractères.
         * @return <code>String</code> La chaine.
         * @see java.lang.Object#toString()
         */
	@Override
	public String toString() {
	    final StringBuilder sb = new StringBuilder("AbstractSimpleEntity [");
	    sb.append(this.id);
	    sb.append("]");
		return sb.toString();
	}
 
}

Et l'objet sur lequel serait posé l'index.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
@Embeddable
public class CleJointure implements Serializable {
 
	/** Identifiant de sérialisation.*/
	private static final long serialVersionUID = -3877767565823706447L;
 
	//Attributs
	/** Source de l'alimentation. */
	private String source;
	/** clé fournie lors l'alimentation. */
	private String cle;
 
 
	//Constructeurs
	/**
         * Constructeur de l'objet CleJointure.java.
         */
	public CleJointure() {
		super();
	}	
	/**
         * Constructeur de l'objet CleJointure.java avec les champs obligatoires.
         * @param source Source de l'alimentation : 
         * Annuaire Fédérateur(AF), ENT ou autres sources non connues actuellement.
         * @param cle clé identifiante, donc unique, de l'object fournie lors de l'alimentation.
         */
	public CleJointure(final String source, final String cle) {
		super();
		this.source = source;
		this.cle = cle;
	}
 
	//Accesseurs
	/**
         * Getter du membre source.
         * @return <code>String</code> le membre source
         */
	public String getSource() {
		return this.source;
	}
	/**
         * Setter du membre source.
         * @param source la nouvelle valeur du membre source  
         */
	public void setSource(final String source) {
		this.source = source;
	}
	/**
         * Getter du membre cle.
         * @return <code>String</code> le membre cle
         */
	public String getCle() {
		return this.cle;
	}
	/**
         * Setter du membre cle.
         * @param cle la nouvelle valeur du membre cle  
         */
	public void setCle(final String cle) {
		this.cle = cle;
	}
 
 
	/**
         * Transforme cette instance en chaine de caractères.
         * @return <code>String</code> La chaine.
         * @see org.esco.sarapis.db.entity.common.AbstractEntity#toString()
         */
	@Override
	public String toString() {
	    final StringBuilder sb = new StringBuilder("CleJointure [");
        sb.append(this.source);
        sb.append(", ");
        sb.append(this.cle);
        sb.append("]");
        return sb.toString();
	}
	/**
         * Donne la valeur de hachage de l'instance.
         * @return <code>int</code> La valeur du hash.
         * @see java.lang.Object#hashCode()
         */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		if (cle == null) {
			result = prime * result;
		} else {
			result = prime * result + cle.hashCode();
		}
		if (source == null) {
			result = prime * result;
		} else {
			result = prime * result + source.hashCode();
		}
		return result;
	}
 
	/**
         * Teste si un objet est égal à cette instance.
         * @param obj l'instance le l'object à comparer.
         * @return <code>boolean</code> : vrai si l'instance est identique, faux sinon
         * @see java.lang.Object#equals(java.lang.Object)
         */
	@Override
	public boolean equals(final Object obj) {
		if (this == obj) { return true; }
		if (obj == null) { return false; }
		if (!(obj instanceof CleJointure)) { return false; }
		final CleJointure other = (CleJointure) obj;
		if (cle == null) {
			if (other.cle != null) { return false; }
		} else if (!cle.equals(other.cle)) { return false; }
		if (source == null) {
			if (other.source != null) { return false; }
		} else if (!source.equals(other.source)) { return false; }
		return true;
	}	
}