Indexen definiëren in JPA

1. Inleiding

In deze tutorial bespreken we het definiëren van indexen met behulp van JPA's @Inhoudsopgave annotatie. Aan de hand van voorbeelden leren we hoe we onze eerste index kunnen definiëren met behulp van JPA en Hibernate. Daarna gaan we de definitie wijzigen en aanvullende manieren laten zien om de index aan te passen.

2. @Inhoudsopgave Annotatie

Laten we beginnen met een korte samenvatting. De database-index is een datastructuur die de snelheid van het ophalen van gegevens op een tafel verbetert ten koste van extra schrijf- en opslagruimte. Meestal is het een kopie van geselecteerde kolommen van gegevens uit een enkele tabel. We moeten indexen maken om de prestaties op onze persistentielaag te verbeteren.

JPA stelt ons in staat om dat te bereiken door indexen te definiëren op basis van onze code met behulp van @Inhoudsopgave. Deze annotatie wordt geïnterpreteerd door het proces voor het genereren van schema's, waarbij automatisch artefacten worden gemaakt. Merk op dat het niet nodig is om een ​​index op te geven voor onze entiteiten.

Laten we nu eens naar de definitie kijken.

2.1. javax.persistence.Index

De indexondersteuning is eindelijk toegevoegd in de JPA 2.1-specificatie door javax.persistence.Index. Met deze annotatie kunnen we een index voor onze tabel definiëren en deze dienovereenkomstig aanpassen:

@Target ({}) @Retention (RUNTIME) public @interface Index {Stringnaam () standaard ""; String columnList (); boolean unique () standaard false; }

Zoals we kunnen zien, is alleen de columnList attribuut is verplicht, dat moeten we definiëren. We zullen later elk van de parameters beter bekijken en voorbeelden bekijken.

2.2. JPA versus slaapstand

We weten dat JPA slechts een specificatie is. Om correct te werken, moeten we ook een persistentieprovider specificeren. Standaard is het Hibernate Framework de implementatie van JPA die wordt geleverd door Spring. Meer hierover leest u hier.

We mogen niet vergeten dat de indexondersteuning erg laat aan de PPV is toegevoegd. Voordien ondersteunen veel ORM Frameworks indexen door hun eigen aangepaste implementatie te introduceren, die mogelijk anders werkt. Het Hibernate Framework deed het ook en introduceerde het org.hibernate.annotations.Index annotatie. Terwijl we met dat raamwerk werken, moeten we oppassen dat het verouderd is sinds de JPA 2.1 specificatie-ondersteuning, en we zouden die van de JPA moeten gebruiken.

Als we wat technische achtergrond hebben, kunnen we voorbeelden bekijken en onze eerste index in JPA definiëren.

3. Het definiëren van het @Inhoudsopgave

In deze sectie implementeren we onze index. Later zullen we proberen het aan te passen en verschillende aanpassingsmogelijkheden presenteren.

Voordat we beginnen, moeten we ons project correct initialiseren en een model definiëren.

Laten we een Leerling entiteit:

@Entity @Table openbare klasse Student implementeert Serializable {@Id @GeneratedValue privé Lange id; private String voornaam; private String achternaam; // getters, setters}

Laten we, als we ons model hebben, de eerste index implementeren. Het enige wat we hoeven te doen is een @Inhoudsopgave annotatie. Dat doen we in de @Tafel annotatie onder de indexen attribuut. Laten we niet vergeten om de naam van de kolom te specificeren:

@Table (indexes = @Index (columnList = "firstName"))

We hebben de allereerste index gedeclareerd met behulp van de Voornaam kolom. Wanneer we het schema voor het maken van een schema uitvoeren, kunnen we het valideren:

[main] DEBUG org.hibernate.SQL - maak index IDX2gdkcjo83j0c2svhvceabnnoh op Student (voornaam)

Nu is het tijd om onze verklaring aan te passen met extra functies.

3.1. @Inhoudsopgave Naam

Zoals we kunnen zien, moet onze index een naam hebben. Als we dit niet specificeren, is dit standaard een door een provider gegenereerde waarde. Als we een aangepast label willen hebben, moeten we gewoon de naam attribuut:

@Index (naam = "fn_index", columnList = "firstName")

Deze variant maakt een index met een door de gebruiker gedefinieerde naam:

[main] DEBUG org.hibernate.SQL - maak index fn_index op student (voornaam)

Bovendien kunnen we onze index in het andere schema maken door de naam van het schema in het naam:

@Index (name = "schema2.fn_index", columnList = "firstName")

3.2. Meerdere kolommen @Inhoudsopgave

Laten we nu de columnList syntaxis:

column :: = index_column [, index_column] * index_column :: = column_name [ASC | DESC]

Zoals we al weten, kunnen we de kolomnamen specificeren die in de index moeten worden opgenomen. Natuurlijk kunnen we meerdere kolommen specificeren voor de enkele index. Dat doen we door de namen te scheiden door een komma:

@Index (name = "mulitIndex1", columnList = "firstName, lastName") @Index (name = "mulitIndex2", columnList = "lastName, firstName")
[main] DEBUG org.hibernate.SQL - maak index mulitIndex1 op student (voornaam, achternaam) [main] DEBUG org.hibernate.SQL - maak index mulitIndex2 op student (achternaam, voornaam)

Merk op dat de persistentieleverancier de gespecificeerde volgorde van de kolommen in acht moet nemen. In ons voorbeeld zijn indexen iets anders, zelfs als ze dezelfde set kolommen specificeren.

3.3. @Inhoudsopgave Bestellen

Zoals we de syntaxis in de vorige sectie hebben bekeken, kunnen we ook specificeren ASC (oplopend) en DESC (aflopende) waarden na de kolomnaam. We gebruiken het om de sorteervolgorde van de waarden in de geïndexeerde kolom in te stellen:

@Index (name = "mulitSortIndex", columnList = "voornaam, achternaam DESC")
[main] DEBUG org.hibernate.SQL - maak index mulitSortIndex op student (voornaam, achternaam desc)

We kunnen de volgorde voor elke kolom specificeren. Als we dat niet doen, wordt uitgegaan van de oplopende volgorde.

3.4. @Inhoudsopgave Uniek

De laatste optionele parameter is een uniek attribuut, dat bepaalt of de index uniek is. Een unieke index zorgt ervoor dat de geïndexeerde velden geen dubbele waarden opslaan. Standaard is het false. Als we het willen wijzigen, kunnen we verklaren:

@Index (name = "uniqueIndex", columnList = "firstName", unique = true)
[main] DEBUG org.hibernate.SQL - wijzig tabel Student voeg beperking uniekIndex uniek (voornaam)

Wanneer we op die manier een index maken, voegen we een uniciteitsbeperking toe aan onze kolommen, op dezelfde manier, hoe als een uniek attribuut op @Kolom annotatie doen. @Inhoudsopgave heeft een voordeel ten opzichte van @Kolom vanwege de mogelijkheid om een ​​unieke beperking met meerdere kolommen te declareren:

@Index (name = "uniqueMulitIndex", columnList = "firstName, lastName", unique = true)

3.5. Meerdere @Inhoudsopgave op een enkele entiteit

Tot nu toe hebben we verschillende varianten van de index geïmplementeerd. Natuurlijk zijn we niet beperkt tot het declareren van een enkele index voor de entiteit. Laten we onze verklaringen verzamelen en elke index tegelijk specificeren. Dat doen we door te herhalen @Inhoudsopgave annotatie tussen accolades en gescheiden door een komma:

@Entity @Table (indexes = {@Index (columnList = "firstName"), @Index (name = "fn_index", columnList = "firstName"), @Index (name = "mulitIndex1", columnList = "voornaam, achternaam" ), @Index (name = "mulitIndex2", columnList = "achternaam, voornaam"), @Index (name = "mulitSortIndex", columnList = "voornaam, achternaam DESC"), @Index (naam = "uniqueIndex", columnList = "firstName", unique = true), @Index (name = "uniqueMulitIndex", columnList = "firstName, lastName", unique = true)}) openbare klasse Student implementeert Serializable

Bovendien kunnen we ook meerdere indexen maken voor dezelfde set kolommen.

3.6. Hoofdsleutel

Als we het hebben over indexen, moeten we een tijdje stoppen bij primaire sleutels. Zoals we weten, wordt elke entiteit beheerd door de EntityManager moet een ID specificeren die is toegewezen aan de primaire sleutel.

Over het algemeen is de primaire sleutel een specifiek type unieke index. Het is de moeite waard eraan toe te voegen dat we de definitie van deze sleutel niet op de eerder gepresenteerde manier hoeven te declareren. Alles wordt automatisch gedaan door de @ID kaart annotatie.

3.7. Niet-entiteit @Inhoudsopgave

Nadat we verschillende manieren hebben geleerd om indexen te implementeren, moeten we dat vermelden @Tafel is niet de enige plaats om ze te specificeren. Op dezelfde manier kunnen we indexen declareren in @BuienRadarNL, @CollectionTable, @JoinTable, @Tafeltennis annotaties. Die voorbeelden worden in dit artikel niet behandeld. Raadpleeg het javax.persistence JavaDoc.

4. Conclusie

In dit artikel hebben we gesproken over het declareren van indexen met JPA. We zijn begonnen met het bekijken van de algemene kennis over hen. Later hebben we onze eerste index geïmplementeerd en via voorbeelden geleerd hoe we deze konden aanpassen door de naam te wijzigen, kolommen op te nemen, volgorde en uniekheid. Uiteindelijk hebben we het gehad over primaire sleutels en aanvullende manieren en plaatsen waar we ze kunnen aangeven.

Zoals altijd zijn de voorbeelden uit het artikel beschikbaar op GitHub.