Comment définir un champ, par exemple emailcomme ayant un index utilisant des annotations JPA. Nous avons besoin d'une clé non unique emailcar il y a littéralement des millions de requêtes sur ce champ par jour, et c'est un peu lent sans la clé.

@Entity
@Table(name="person", 
       uniqueConstraints=@UniqueConstraint(columnNames={"code", "uid"}))
public class Person {
    // Unique on code and uid
    public String code;
    public String uid;

    public String username;
    public String name;
    public String email;
}

J'ai vu une annotation spécifique à l'hibernation, mais j'essaie d'éviter les solutions spécifiques au fournisseur car nous sommes toujours en train de décider entre l'hibernation et le datanucleus.

METTRE À JOUR:

Depuis JPA 2.1, vous pouvez le faire. Voir: l'annotation @Index n'est pas autorisée pour cet emplacement

Avec JPA 2.1, vous devriez pouvoir le faire.

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Index;
import javax.persistence.Table;

@Entity
@Table(name = "region",
       indexes = {@Index(name = "my_index_name",  columnList="iso_code", unique = true),
                  @Index(name = "my_index_name2", columnList="name",     unique = false)})
public class Region{

    @Column(name = "iso_code", nullable = false)
    private String isoCode;

    @Column(name = "name", nullable = false)
    private String name;

} 

Mise à jour : Si jamais vous avez besoin de créer et d'indexer avec deux colonnes ou plus, vous pouvez utiliser des virgules. Par exemple:

@Entity
@Table(name    = "company__activity", 
       indexes = {@Index(name = "i_company_activity", columnList = "activity_id,company_id")})
public class CompanyActivity{

Une collection unique d'annotations d'index triées sur le volet

= Spécifications =

• JPA 2.1+: javax.persistence.Index(ou voir JSR-000338 . PDF, p 452, point 1.11.23)
  L'APP @Indexannotation ne peut être utilisé dans le cadre d' une autre annotation comme @Table, @SecondaryTable, etc .:

  @Table(indexes = { @Index(...) })

• JDO 2.1+:javax.jdo.annotations.Index

= Cadres ORM =

• ♥ Mise en veille prolongée ORM : org.hibernate.annotations.Index;
• OpenJPA : org.apache.openjpa.persistence.jdbc.Indexet org.apache.openjpa.persistence.jdbc.ElementIndex(voir Guide de référence );
• EclipseLink : org.eclipse.persistence.annotations.Index;
• DataNucleus : org.datanucleus.api.jpa.annotations.Index;
• Carbonado (GitHub) : com.amazon.carbonado.Index;
• EBean : com.avaje.ebean.annotation.Index ou io.ebean.annotation.Index?
• Ujorm : Annotation org.ujorm.orm.annot.Column, indexet uniqueIndexpropriétés;
• requery ( GitHub . Java, Kotlin, Android): Annotation io.requery.Index;

• Exposé ( bibliothèque SQL Kotlin ): org.jetbrains.exposed.sql.Index , org.jetbrains.exposed.sql.Table # index () . Exemple:

  object Persons : IdTable() {
      val code = varchar("code", 50).index()
  }

= ORM pour Android =

• ♥ ActiveAndroid : Annotation com.activeandroid.annotation.Columna index, indexGroups, uniqueet uniqueGroupspropriétés;
  ^{MISE À JOUR [2018]: ActiveAndroid était un bon ORM il y a 4 ans, mais malheureusement, l'auteur de la bibliothèque a arrêté de le maintenir, alors quelqu'un a bifurqué, corrigé des bogues et l'a rebaptisé ReActiveAndroid - utilisez ceci si vous démarrez un nouveau projet ou reportez-vous au Guide de migration si vous souhaitez remplacer ActiveAndroid dans un projet hérité.}
• ReActiveAndroid : Annotation com.reactiveandroid.annotation.Columna index, indexGroups, uniqueetuniqueGroups propriétés;
• ORMLite : l'annotation com.j256.ormlite.field.DatabaseFielda unindex propriété;
• greenDAO :org.greenrobot.greendao.annotation.Index ;
• ORMAN (GitHub) :org.orman.mapper.annotation.Index ;
• ★ DBFlow (GitHub) : com.raizlabs.android.dbflow.sql.index.Index( exemple d'utilisation);
• autres (beaucoup de bibliothèques ORM sur l'arsenal Android).

= Autre (difficile à catégoriser) =

• Realm - Alternative DB pour iOS / Android: Annotationio.realm.annotations.Index ;
• Empire-db - une couche d'abstraction DB relationnelle légère mais puissante basée sur JDBC. Il n'a pas de définition de schéma via des annotations;
• Kotlin NoSQL (GitHub) - un DSL réactif et de type sécurisé pour travailler avec les bases de données NoSQL (PoC): ???
• Slick - Cartographie relationnelle fonctionnelle réactive pour Scala. Il n'a pas de définition de schéma via des annotations.

Optez pour l'un d'entre eux.

JPA 2.1 (enfin) ajoute le support des index et des clés étrangères! Consultez ce blog pour plus de détails. JPA 2.1 fait partie de Java EE 7, qui est sorti.

Si vous aimez vivre à la périphérie, vous pouvez obtenir le dernier instantané pour eclipselink à partir de leur référentiel maven (groupId: org.eclipse.persistence, artifactId: eclipselink, version: 2.5.0-SNAPSHOT). Pour les annotations JPA uniquement (qui devraient fonctionner avec n'importe quel fournisseur une fois qu'elles prennent en charge la version 2.1), utilisez artifactID: javax.persistence, version: 2.1.0-SNAPSHOT.

Je l'utilise pour un projet qui ne sera terminé qu'après sa sortie, et je n'ai remarqué aucun problème horrible (bien que je ne fasse rien de trop complexe avec lui).

MISE À JOUR (26 septembre 2013): Aujourd'hui, les versions et versions candidates d'eclipselink sont disponibles dans le référentiel central (principal), vous n'avez donc plus à ajouter le référentiel eclipselink dans les projets Maven. La dernière version est la 2.5.0 mais 2.5.1-RC3 est également présente. Je passerais à 2.5.1 dès que possible en raison de problèmes avec la version 2.5.0 (le truc modelgen ne fonctionne pas).

Dans JPA 2.1, vous devez effectuer les opérations suivantes

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Index;
import javax.persistence.Table;

@Entity(name="TEST_PERSON")
@Table(
    name="TEST_PERSON", 
    indexes = {
       @Index(name = "PERSON_INDX_0", columnList = "age"),
       @Index(name = "PERSON_INDX_1", columnList = "fName"),
       @Index(name = "PERSON_INDX_1", columnList = "sName")  })
public class TestPerson {

    @Column(name = "age", nullable = false)
    private int age;

    @Column(name = "fName", nullable = false)
    private String firstName;

    @Column(name = "sName", nullable = false)
    private String secondName;

    @Id
    private long id;

    public TestPerson() {
    }
}

Dans l'exemple ci-dessus, la table TEST_PERSON aura 3 index:

• index unique sur l'ID de clé primaire

• index sur AGE

• index composé sur FNAME, SNAME

Remarque 1: vous obtenez l'index composé en ayant deux annotations @Index avec le même nom

Remarque 2: vous spécifiez le nom de la colonne dans la columnList et non dans le champ fieldName

J'aimerais vraiment pouvoir spécifier des index de base de données de manière standardisée mais, malheureusement, cela ne fait pas partie de la spécification JPA (peut-être parce que la prise en charge de la génération DDL n'est pas requise par la spécification JPA, qui est une sorte de barrage pour une telle caractéristique).

Vous devrez donc vous fier à une extension spécifique au fournisseur pour cela. Hibernate, OpenJPA et EclipseLink proposent clairement une telle extension. Je ne peux pas confirmer pour DataNucleus mais comme la définition des index fait partie de JDO, je suppose que c'est le cas.

J'espère vraiment que le support des index sera standardisé dans les prochaines versions de la spécification et donc en quelque sorte en désaccord avec les autres réponses, je ne vois aucune bonne raison de ne pas inclure une telle chose dans JPA (d'autant plus que la base de données n'est pas toujours sous votre contrôle) pour une prise en charge optimale de la génération DDL.

Au fait, je suggère de télécharger la spécification JPA 2.0.

Autant que je sache, il n'y a pas de moyen entre les fournisseurs JPA de spécifier des index. Cependant, vous pouvez toujours les créer à la main directement dans la base de données, la plupart des bases de données les récupèrent automatiquement lors de la planification des requêtes.

EclipseLink a fourni une annotation (par exemple @Index ) pour définir un index sur les colonnes. Il y a un exemple de son utilisation. Une partie de l'exemple est incluse ...

Les champs firstName et lastName sont indexés, ensemble et individuellement.

@Entity
@Index(name="EMP_NAME_INDEX", columnNames={"F_NAME","L_NAME"})  // Columns indexed together
public class Employee{
    @Id
    private long id;

    @Index                      // F_NAME column indexed
    @Column(name="F_NAME")
    private String firstName;

    @Index                      // L_NAME column indexed
    @Column(name="L_NAME")
    private String lastName;
    ...
}

OpenJPA vous permet de spécifier une annotation non standard pour définir l'index sur la propriété.

Les détails sont ici .

Pour résumer les autres réponses:

• Hiberner: org.hibernate.annotations.Index
• OpenJPA: org.apache.openjpa.persistence.jdbc.Index
• EclipseLink: org.eclipse.persistence.annotations.Index

J'irais juste pour l'un d'entre eux. Il viendra de toute façon avec JPA 2.1 et ne devrait pas être trop difficile à changer dans le cas où vous voudriez vraiment changer de fournisseur JPA.

Il n'est pas possible de faire cela en utilisant l'annotation JPA. Et cela a du sens: lorsqu'une UniqueConstraint définit clairement des règles métier, un index n'est qu'un moyen d'accélérer la recherche. Donc, cela devrait vraiment être fait par un DBA.

Cette solution est pour EclipseLink 2.5 et fonctionne (testé):

@Table(indexes = {@Index(columnList="mycol1"), @Index(columnList="mycol2")})
@Entity
public class myclass implements Serializable{
      private String mycol1;
      private String mycol2;
}

Cela suppose un ordre ascendant.