Cartographie de l'hibernation entre le Postgresql enum et le Java enum

vous n'avez pas à créer tous les types D'hibernation suivants manuellement. Vous pouvez simplement les obtenir via Maven Central en utilisant la dépendance suivante:

<dependency>
    <groupId>com.vladmihalcea</groupId>
    <artifactId>hibernate-types-52</artifactId>
    <version>${hibernate-types.version}</version>
</dependency>

pour plus d'information, consultez le mise en veille prolongée-types de projet open-source.

expliqué dans cet article, si vous pouvez facilement mapper Java Enum à un type de colonne PostgreSQL Enum en utilisant le type personnalisé suivant:

public class PostgreSQLEnumType extends org.hibernate.type.EnumType {

    public void nullSafeSet(
            PreparedStatement st, 
            Object value, 
            int index, 
            SharedSessionContractImplementor session) 
        throws HibernateException, SQLException {
        if(value == null) {
            st.setNull( index, Types.OTHER );
        }
        else {
            st.setObject( 
                index, 
                value.toString(), 
                Types.OTHER 
            );
        }
    }
}

Pour l'utiliser, vous devez annoter le terrain avec the Hibernate @Type annotation telle qu'illustrée dans l'exemple suivant:

@Entity(name = "Post")
@Table(name = "post")
@TypeDef(
    name = "pgsql_enum",
    typeClass = PostgreSQLEnumType.class
)
public static class Post {

    @Id
    private Long id;

    private String title;

    @Enumerated(EnumType.STRING)
    @Column(columnDefinition = "post_status_info")
    @Type( type = "pgsql_enum" )
    private PostStatus status;

    //Getters and setters omitted for brevity
}

ce mapping suppose que vous avez le post_status_info type enum dans PostgreSQL:

CREATE TYPE post_status_info AS ENUM (
    'PENDING', 
    'APPROVED', 
    'SPAM'
)

ça y est, il fonctionne comme un charme. Voici un test sur GitHub qui le prouve.

Comme dit dans 8.7.3. Type de Sécurité de Postgres Docs:

si vous avez vraiment besoin de faire quelque chose comme ça, vous pouvez soit écrire un opérateur personnalisé ou ajouter des casts explicites à votre requête:

alors si vous voulez une solution rapide et simple, faites comme ceci:

<query name="getAllMoves">
<![CDATA[
    select move from Move move
    where cast(directiontomove as text) = cast(:directionToMove as text)
]]>
</query>

Malheureusement, vous ne pouvez pas le faire tout simplement avec deux points:

permettez-moi de commencer en disant que j'ai été capable de faire cela en utilisant l'hibernation 4.3.x et Postgres 9.x.

j'ai basé ma solution sur quelque chose de similaire à ce que vous avez fait. Je crois que si vous combinez

@Type(type = "org.hibernate.type.EnumType",
parameters = {
        @Parameter(name  = "enumClass", value = "full.path.to.Move$Direction"),
        @Parameter(name = "type", value = "12"),
        @Parameter(name = "useNamed", value = "true")
})

et

@Override
public void nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session) throws HibernateException, SQLException {
  if (value == null) {
    st.setNull(index, Types.VARCHAR);
  }
  else {
    st.setObject(index, ((Enum) value).name(), Types.OTHER);
  }
}

vous devriez être capable d'obtenir quelque chose dans le sens de ceci, sans avoir à faire l'un ou l'autre des changements ci-dessus.

@Type(type = "org.hibernate.type.EnumType",
parameters = {
        @Parameter(name  = "enumClass", value = "full.path.to.Move$Direction"),
        @Parameter(name = "type", value = "1111"),
        @Parameter(name = "useNamed", value = "true")
})

je crois que cela fonctionne puisque vous dites essentiellement Hibernate de cartographier l'enum à un type d'autre (Type.Autres = = 1111). Il peut s'agir d'une solution légèrement fragile étant donné la valeur des Types.D'autres pourraient changer. Cependant, cela fournirait beaucoup moins de code dans l'ensemble.

j'ai une autre approche avec un convertisseur de persistance:

import javax.persistence.Convert;

@Column(name = "direction", nullable = false)
@Converter(converter = DirectionConverter.class)
private Direction directionToMove;

C'est un convertisseur définition:

import javax.persistence.Converter;

@Converter
public class DirectionConverter implements AttributeConverter<Direction, String> {
    @Override
    public String convertToDatabaseColumn(Direction direction) {
        return direction.name();
    }

    @Override
    public Direction convertToEntityAttribute(String string) {
        return Diretion.valueOf(string);
    }
}

il ne résout pas la mise en correspondance au type enum de psql, mais il peut simuler @Enumentype.Chaîne de caractères) ou @Enumerated (EnumType.ORDINAL) dans le bon sens.

pour la direction ordinale.ordinal () et Direction.les valeurs de()[numéro].