Jak zdefiniujesz pole, np. emailJako posiadające indeks przy użyciu adnotacji JPA. Potrzebujemy nieunikalnego klucza, emailponieważ w tym polu dziennie są dosłownie miliony zapytań, a bez klucza jest trochę powolny.

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

Widziałem adnotację specyficzną dla hibernacji, ale staram się unikać rozwiązań specyficznych dla dostawcy, ponieważ wciąż decydujemy między hibernacją a jądrem danych.

AKTUALIZACJA:

Od JPA 2.1 możesz to zrobić. Zobacz: Adnotacja @Index jest niedozwolona w tej lokalizacji

Z JPA 2.1 powinieneś to zrobić.

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;

} 

Aktualizacja : jeśli kiedykolwiek będziesz musiał tworzyć i indeksować z dwiema lub więcej kolumnami, możesz użyć przecinków. Na przykład:

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

Unikalny, ręcznie wybrany zbiór adnotacji w indeksie

= Dane techniczne =

• JPA 2.1+: javax.persistence.Index(lub zobaczyć JSR-000338 . PDF, str 452, poz 01.11.23)
  WZP @Indexadnotacje mogą być używane tylko jako część innego jak adnotacji @Table, @SecondaryTableitp .:

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

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

= ORM Frameworks =

• ♥ hibernacji ORM : org.hibernate.annotations.Index;
• OpenJPA : org.apache.openjpa.persistence.jdbc.Indexi org.apache.openjpa.persistence.jdbc.ElementIndex(patrz Przewodnik );
• 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 czy io.ebean.annotation.Index?
• Ujorm : powiadamiania org.ujorm.orm.annot.Column, indexi uniqueIndexwłaściwości;
• requery ( GitHub . Java, Kotlin, Android): Adnotacje io.requery.Index;

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

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

= ORM dla Androida =

• ♥ ActiveAndroid : Adnotacja com.activeandroid.annotation.Columnzawiera index, indexGroups, uniquei uniqueGroupswłaściwości;
  ^{UPDATE [2018]: ActiveAndroid był fajnym ORMem 4 lata temu, ale niestety autor biblioteki przestał go utrzymywać, więc ktoś rozwidlił, naprawił błędy i przemianował go na ReActiveAndroid - użyj tego, jeśli zaczynasz nowy projekt lub zapoznaj się z Przewodnikiem migracji, jeśli chcesz zastąpić ActiveAndroid w starszym projekcie.}
• ReActiveAndroid : Adnotacja com.reactiveandroid.annotation.Columnma index, indexGroups, unique, i uniqueGroupswłaściwości;
• ORMLite : Adnotacja com.j256.ormlite.field.DatabaseFieldma indexwłaściwość;
• greenDAO : org.greenrobot.greendao.annotation.Index;
• ORMAN (GitHub) : org.orman.mapper.annotation.Index;
• ★ DBFlow (GitHub) : com.raizlabs.android.dbflow.sql.index.Index( przykład użycia);
• inne (wiele bibliotek ORM w Android Arsenal).

= Inne (trudne do skategoryzowania) =

• Realm - Alternatywna baza danych dla iOS / Android: Adnotacja io.realm.annotations.Index;
• Empire-db - lekka, ale potężna relacyjna warstwa abstrakcji DB oparta na JDBC. Nie ma definicji schematu za pomocą adnotacji;
• Kotlin NoSQL (GitHub) - reaktywny i bezpieczny typ DSL do pracy z bazami danych NoSQL (PoC): ???
• Zręczne - reaktywne funkcjonalne mapowanie relacyjne dla Scala. Nie ma definicji schematu za pomocą adnotacji.

Po prostu wybierz jedną z nich.

JPA 2.1 (wreszcie) dodaje obsługę indeksów i kluczy obcych! Zobacz ten blog, aby uzyskać szczegółowe informacje. JPA 2.1 jest częścią Java EE 7, która jest obecnie.

Jeśli lubisz żyć na krawędzi, możesz pobrać najnowszą migawkę dla eclipselink z ich repozytorium maven (groupId: org.eclipse.persistence, artifactId: eclipselink, wersja: 2.5.0-SNAPSHOT). Tylko dla adnotacji JPA (które powinny działać z każdym dostawcą, gdy obsługują 2.1) użyj artifactID: javax.persistence, wersja: 2.1.0-SNAPSHOT.

Używam go do projektu, który nie zostanie ukończony przed jego wydaniem i nie zauważyłem żadnych okropnych problemów (chociaż nie robię z nim nic zbyt skomplikowanego).

AKTUALIZACJA (26 września 2013 r.): Obecnie wersje eclipselink do wydania i wydania kandydatów do wydania są dostępne w centralnym (głównym) repozytorium, więc nie trzeba już dodawać repozytorium eclipselink w projektach Maven. Najnowsza wersja to 2.5.0, ale obecna jest również wersja 2.5.1-RC3. Przerzuciłbym się na 2.5.1 JAK NAJSZYBCIEJ z powodu problemów z wersją 2.5.0 (rzeczy modelgen nie działają).

W JPA 2.1 musisz wykonać następujące czynności

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

W powyższym przykładzie tabela TEST_PERSON będzie miała 3 indeksy:

• unikalny indeks identyfikatora klucza podstawowego

• indeks na AGE

• indeks złożony na FNAME, SNAME

Uwaga 1: Indeks złożony uzyskuje się, mając dwie adnotacje @Index o tej samej nazwie

Uwaga 2: Nazwę kolumny określasz w columnList, a nie w fieldName

Naprawdę chciałbym móc określić indeksy bazy danych w ustandaryzowany sposób, ale niestety nie jest to częścią specyfikacji JPA (może dlatego, że specyfikacja JPA nie wymaga obsługi generacji DDL, co jest rodzajem blokady drogowej dla taka funkcja).

Musisz więc polegać na rozszerzeniu specyficznym dla dostawcy. Hibernate, OpenJPA i EclipseLink wyraźnie oferują takie rozszerzenie. Nie mogę potwierdzić dla DataNucleus, ale ponieważ definicja indeksów jest częścią JDO, myślę, że tak.

Naprawdę mam nadzieję, że obsługa indeksu zostanie ustandaryzowana w kolejnych wersjach specyfikacji i tym samym jakoś nie będzie się zgadzać z innymi odpowiedziami, nie widzę żadnego powodu, aby nie umieszczać czegoś takiego w JPA (zwłaszcza, że ​​baza danych nie zawsze jest pod twoją kontrolą) dla optymalnej obsługi generacji DDL.

Przy okazji sugeruję pobranie specyfikacji JPA 2.0.

O ile mi wiadomo, nie istnieje sposób określania indeksów przez dostawców między JPA. Jednak zawsze możesz utworzyć je ręcznie bezpośrednio w bazie danych, większość baz danych pobierze je automatycznie podczas planowania zapytań.

EclipseLink dostarczył adnotację (np. @Index ) w celu zdefiniowania indeksu w kolumnach. Oto przykład jego użycia. Część przykładu jest dołączona ...

Pola firstName i lastName są indeksowane razem i indywidualnie.

@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 umożliwia określenie niestandardowych adnotacji w celu zdefiniowania indeksu właściwości.

Szczegóły tutaj .

Podsumowując pozostałe odpowiedzi:

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

Po prostu wybrałbym jednego z nich. I tak będzie dostarczany z JPA 2.1 i nie powinien być zbyt trudny do zmiany w przypadku, gdy naprawdę chcesz zmienić dostawcę JPA.

Nie można tego zrobić za pomocą adnotacji JPA. I to ma sens: gdy UniqueConstraint jasno definiuje reguły biznesowe, indeks jest tylko sposobem na przyspieszenie wyszukiwania. Więc powinno to być naprawdę zrobione przez administratora.

To rozwiązanie jest dla EclipseLink 2.5 i działa (przetestowane):

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

Zakłada to kolejność rosnącą.