Come si definisce un campo, ad esempio emailse ha un indice utilizzando le annotazioni JPA. Abbiamo bisogno di una chiave non univoca emailperché ci sono letteralmente milioni di query su questo campo al giorno, ed è un po 'lento senza la chiave.

@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;
}

Ho visto un'annotazione specifica di ibernazione ma sto cercando di evitare soluzioni specifiche del fornitore poiché stiamo ancora decidendo tra ibernazione e datanucleus.

AGGIORNARE:

A partire da JPA 2.1, puoi farlo. Vedere: L'annotazione @Index non è consentita per questa posizione

Con JPA 2.1 dovresti essere in grado di farlo.

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;

} 

Aggiornamento : se hai bisogno di creare e indicizzare con due o più colonne, puoi usare le virgole. Per esempio:

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

Una raccolta unica selezionata a mano di annotazioni dell'indice

= Specifiche =

• JPA 2.1+: javax.persistence.Index(oppure consultare JSR-000.338 . PDF, p 452, punto 11.1.23)
  L'APP @Indexannotazione può essere utilizzato solo come parte di un altro annotazioni come @Table, @SecondaryTable, ecc .:

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

• JDO 2.1 e versioni successive:javax.jdo.annotations.Index

= Framework ORM =

• ♥ Hibernate ORM : org.hibernate.annotations.Index;
• OpenJPA : org.apache.openjpa.persistence.jdbc.Indexe org.apache.openjpa.persistence.jdbc.ElementIndex(vedi Guida di riferimento );
• 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 o io.ebean.annotation.Index?
• Ujorm : annotazione org.ujorm.orm.annot.Column, indexe uniqueIndexproprietà;
• requery ( GitHub . Java, Kotlin, Android): Annotazione io.requery.Index;

• Exposed ( Kotlin SQL Library): org.jetbrains.exposed.sql.Index , org.jetbrains.exposed.sql.Table # index () . Esempio:

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

= ORM per Android =

• ♥ ActiveAndroid : Annotazione com.activeandroid.annotation.Columnha index, indexGroups, unique, e uniqueGroupsproprietà;
  ^{AGGIORNAMENTO [2018]: ActiveAndroid era un bel ORM 4 anni fa, ma sfortunatamente l'autore della libreria ha smesso di mantenerlo, quindi qualcuno ha biforcato, risolto bug e ribattezzato ReActiveAndroid : usalo se stai iniziando un nuovo progetto o fare riferimento alla Guida alla migrazione se si desidera sostituire ActiveAndroid in un progetto legacy.}
• ReActiveAndroid : Annotazione com.reactiveandroid.annotation.Columnha index, indexGroups, unique, e uniqueGroupsproprietà;
• ORMLite : l'annotazione com.j256.ormlite.field.DatabaseFieldha una indexproprietà;
• greenDAO : org.greenrobot.greendao.annotation.Index;
• ORMAN (GitHub) : org.orman.mapper.annotation.Index;
• ★ DBFlow (GitHub) : com.raizlabs.android.dbflow.sql.index.Index( esempio di utilizzo);
• altro (molte librerie ORM nell'Arsenale Android).

= Altro (difficile da classificare) =

• Regno - DB alternativo per iOS / Android: Annotazione io.realm.annotations.Index;
• Empire-db : un livello di astrazione DB relazionale leggero ma potente basato su JDBC. Non ha una definizione dello schema tramite annotazioni;
• Kotlin NoSQL (GitHub) - un DSL reattivo e indipendente dai tipi per lavorare con database NoSQL (PoC): ???
• Slick - Reactive Functional Relational Mapping for Scala. Non ha una definizione dello schema tramite annotazioni.

Scegli uno di loro.

JPA 2.1 (finalmente) aggiunge il supporto per indici e chiavi esterne! Vedi questo blog per i dettagli. JPA 2.1 fa parte di Java EE 7, che è uscito.

Se ti piace vivere al limite, puoi ottenere l'ultima istantanea per eclipselink dal loro repository maven (groupId: org.eclipse.persistence, artifactId: eclipselink, versione: 2.5.0-SNAPSHOT). Solo per le annotazioni JPA (che dovrebbero funzionare con qualsiasi provider una volta che supportano 2.1) utilizzare artifactID: javax.persistence, versione: 2.1.0-SNAPSHOT.

Lo sto usando per un progetto che non sarà finito fino a dopo il suo rilascio, e non ho notato problemi orribili (anche se non sto facendo nulla di troppo complesso con esso).

AGGIORNAMENTO (26 settembre 2013): Al giorno d'oggi le versioni release e release candidate di eclipselink sono disponibili nel repository centrale (principale), quindi non è più necessario aggiungere il repository eclipselink nei progetti Maven. L'ultima versione di rilascio è 2.5.0 ma è presente anche 2.5.1-RC3. Passerei alla 2.5.1 al più presto a causa di problemi con la versione 2.5.0 (la roba modelgen non funziona).

In JPA 2.1 è necessario eseguire le seguenti operazioni

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() {
    }
}

Nell'esempio sopra la tabella TEST_PERSON avrà 3 indici:

• indice univoco sull'ID chiave primaria

• indice su AGE

• indice composto su FNAME, SNAME

Nota 1: ottieni l'indice composto avendo due annotazioni @Index con lo stesso nome

Nota 2: specificare il nome della colonna in columnList e non in fieldName

Mi piacerebbe davvero essere in grado di specificare gli indici del database in modo standardizzato ma, purtroppo, questo non fa parte della specifica JPA (forse perché il supporto della generazione DDL non è richiesto dalla specifica JPA, che è una sorta di blocco stradale per tale caratteristica).

Quindi dovrai fare affidamento su un'estensione specifica del provider per questo. Hibernate, OpenJPA ed EclipseLink offrono chiaramente tale estensione. Non posso confermare per DataNucleus ma poiché la definizione degli indici fa parte di JDO, immagino che lo faccia.

Spero davvero che il supporto dell'indice venga standardizzato nelle prossime versioni delle specifiche e quindi in qualche modo non sono d'accordo con altre risposte, non vedo alcuna buona ragione per non includere una cosa del genere in JPA (soprattutto perché il database non è sempre sotto il tuo controllo) per un supporto ottimale per la generazione di DDL.

A proposito, suggerisco di scaricare le specifiche JPA 2.0.

Per quanto ne so, non esiste un modo cross-JPA-Provider per specificare gli indici. Tuttavia, puoi sempre crearli a mano direttamente nel database, la maggior parte dei database li raccoglierà automaticamente durante la pianificazione delle query.

EclipseLink ha fornito un'annotazione (ad esempio @Index ) per definire un indice sulle colonne. C'è un esempio del suo utilizzo. Parte dell'esempio è inclusa ...

I campi firstName e lastName vengono indicizzati, insieme e individualmente.

@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 consente di specificare un'annotazione non standard per definire l'indice sulla proprietà.

I dettagli sono qui .

Per riassumere le altre risposte:

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

Vorrei solo uno di loro. Verrà comunque fornito con JPA 2.1 e non dovrebbe essere troppo difficile da modificare nel caso in cui si desideri davvero cambiare provider JPA.

Non è possibile farlo utilizzando l'annotazione JPA. E questo ha senso: laddove un UniqueConstraint definisce chiaramente le regole aziendali, un indice è solo un modo per rendere la ricerca più veloce. Quindi questo dovrebbe davvero essere fatto da un DBA.

Questa soluzione è per EclipseLink 2.5 e funziona (testata):

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

Ciò presuppone un ordine ascendente.