Annotation JPA pour le type TEXT PostgreSQL

1. Introduction

Dans ce rapide tutoriel, nous expliquerons comment gérer le type PostgreSQL TEXT à l'aide des annotations définies par la spécification JPA .

2. Le type TEXT dans PostgreSQL

Lorsque nous travaillons avec PostgresSQL, nous pouvons, périodiquement, avoir besoin de stocker une chaîne de longueur arbitraire.

Pour cela, PostgreSQL fournit trois types de caractères:

  • CHAR (n)
  • VARCHAR (n)
  • TEXTE

Malheureusement, le type TEXT ne fait pas partie des types gérés par la norme SQL. Cela signifie que si nous voulons utiliser des annotations JPA dans nos entités de persistance, nous pouvons avoir un problème .

En effet, la spécification JPA utilise la norme SQL. Par conséquent, il ne définit pas un moyen simple de gérer ce type d'objet en utilisant, par exemple, une annotation @Text .

Heureusement, nous avons quelques possibilités pour gérer le type de données TEXT pour une base de données PostgreSQL:

  • Nous pouvons utiliser l' annotation @Lob
  • Alternativement, nous pouvons également utiliser l' annotation @Column , combinée avec l' attribut columnDefinition

Jetons maintenant un œil aux deux solutions en commençant par l' annotation @Lob .

3. @Lob

Comme son nom l' indique, un lob est l arge ob Ject. En termes de base de données, les colonnes lob sont utilisées pour stocker des textes très longs ou des fichiers binaires .

Nous pouvons choisir entre deux types de lobs:

  • CLOB - un lob de caractères utilisé pour stocker des textes
  • BLOB - un lob binaire qui peut être utilisé pour stocker des données binaires

Nous pouvons utiliser l' annotation JPA @Lob pour mapper de grands champs sur des types d'objets de base de données volumineux.

Lorsque nous utilisons l' enregistrement @Lob sur un attribut de type String , la spécification JPA indique que le fournisseur de persistance doit utiliser un objet de type caractère volumineux pour stocker la valeur de l'attribut. Par conséquent, PostgreSQL peut traduire un lob de caractères en un type TEXT.

Supposons que nous ayons un objet d'entité Exam simple , avec un champ de description , qui pourrait avoir une longueur arbitraire:

@Entity public class Exam { @Id @GeneratedValue(strategy=GenerationType.AUTO) private Long id; @Lob private String description; } 

En utilisant l' annotation @Lob sur le champ de description, nous demandons à Hibernate de gérer ce champ en utilisant le type TEXT de PostgreSQL.

4. @Colonne

Une autre option pour gérer le type TEXT consiste à utiliser l' annotation @Column , avec la propriété columnDefinition .

Utilisons à nouveau le même objet d'entité Exam , mais cette fois, nous ajouterons un champ TEXT, qui pourrait être d'une longueur arbitraire:

@Entity public class Exam { @Id @GeneratedValue(strategy=GenerationType.AUTO) private Long id; @Lob private String description; @Column(columnDefinition="TEXT") private String text; }

Dans cet exemple, nous utilisons l'annotation @Column (columnDefinition = ”TEXT”) . L'utilisation de l' attribut columnDefinition nous permet de spécifier le fragment SQL qui sera utilisé lors de la construction de la colonne de données pour ce type.

5. Rassembler tout cela

Dans cette section, nous écrirons un test unitaire simple pour vérifier que notre solution fonctionne:

@Test public void givenExam_whenSaveExam_thenReturnExpectedExam() { Exam exam = new Exam(); exam.setDescription("This is a description. Sometimes the description can be very very long! "); exam.setText("This is a text. Sometimes the text can be very very long!"); exam = examRepository.save(exam); assertEquals(examRepository.find(exam.getId()), exam); }

Dans cet exemple, nous commençons par créer un nouvel objet Exam et le conserver dans notre base de données. Nous récupérons ensuite l' objet Exam de la base de données et comparons le résultat avec l'examen original que nous avons créé.

Pour démontrer le point, si nous modifions rapidement le champ de description sur notre entité d' examen :

@Column(length = 20) private String description; 

Lorsque nous réexécutons notre test, nous verrons une erreur:

ERROR o.h.e.jdbc.spi.SqlExceptionHelper - Value too long for column "TEXT VARCHAR(20)"

6. Conclusion

Dans ce didacticiel, nous avons couvert deux approches pour l'utilisation des annotations JPA avec le type PostgreSQL TEXT.

Nous avons commencé par expliquer à quoi sert le type TEXT, puis nous avons vu comment nous pouvons utiliser les annotations JPA @Lob et @Column pour enregistrer des objets String en utilisant le type TEXT défini par PostgreSQL.

Comme toujours, le code source complet de l'article est disponible à l'adresse over sur GitHub.