如何在Hibernate中映射PostgreSQL Interval列类型？

问题描述 投票：0回答：6

在 PostgreSQL 下，我使用 

PersistentDuration
来映射 sql 类型间隔和持续时间，但它不起作用。

另一位用户发现了同样的问题并提供了他自己的课程：

public void nullSafeSet(PreparedStatement statement, Object value, int index) 
        throws HibernateException, SQLException { 
    if (value == null) { 
        statement.setNull(index, Types.OTHER); 
    } else { 
        Long interval = ((Long) value).longValue(); 
        Long hours = interval / 3600; 
        Long minutes = (interval - (hours * 3600)) / 60; 
        Long secondes = interval - (hours * 3600) - minutes * 60; 
            statement.setString(index, "'"+ hours +":" 
                    + intervalFormat.format(minutes) + ":" 
                    + intervalFormat.format(secondes)+"'"); 

    } 
}

但它不适用于真实格式，因为它假设间隔模式只是 “时：分：秒”。事实并非如此：参见

这里有一些我需要从数据库中解析的真实例子：

1 天 00:29:42
00:29:42
1 周 00:29:42
1 周 2 天 00:29:42
1 个月 1 周 2 天 00:29:42
1 年 00:29:42
1 个十年 00:29:42

http://www.postgresql.org/docs/current/interactive/datatype-datetime.html

你有干净的解决方案吗？

postgresql hibernate intervals custom-type column-types
6个回答
5
投票

这是 JPA、Hibernate（带注释）的工作解决方案。

这是实体类的开头（对于具有 Interval 列的表）：

@Entity
@Table(name="table_with_interval_col")
@TypeDef(name="interval", typeClass = Interval.class)
public class TableWithIntervalCol implements Serializable {

这是间隔列：

@Column(name = "interval_col",  nullable = false)
@Type(type = "interval")    
private Integer intervalCol;

这是 Interval 类：

package foo.bar.hibernate.type;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Date;

import org.hibernate.HibernateException;
import org.hibernate.usertype.UserType;
import org.postgresql.util.PGInterval;


/**
 * Postgres Interval type
 * 
 * @author bpgergo
 * 
 */
public class Interval implements UserType {
    private static final int[] SQL_TYPES = { Types.OTHER };

    @Override
    public int[] sqlTypes() {
        return SQL_TYPES;
    }

    @SuppressWarnings("rawtypes")
    @Override
    public Class returnedClass() {
        return Integer.class;
    }

    @Override
    public boolean equals(Object x, Object y) throws HibernateException {
        return x.equals(y);
    }

    @Override
    public int hashCode(Object x) throws HibernateException {
        return x.hashCode();
    }

    @Override
    public Object nullSafeGet(ResultSet rs, String[] names, Object owner)
            throws HibernateException, SQLException {
        String interval = rs.getString(names[0]);
        if (rs.wasNull() || interval == null) {
            return null;
        }
        PGInterval pgInterval = new PGInterval(interval);
        Date epoch = new Date(0l);
        pgInterval.add(epoch);
        return Integer.valueOf((int)epoch.getTime() / 1000);
    }

    public static String getInterval(int value){
        return new PGInterval(0, 0, 0, 0, 0, value).getValue();
    }


    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index)
            throws HibernateException, SQLException {
        if (value == null) {
            st.setNull(index, Types.VARCHAR);
        } else {
            //this http://postgresql.1045698.n5.nabble.com/Inserting-Information-in-PostgreSQL-interval-td2175203.html#a2175205
            st.setObject(index, getInterval(((Integer) value).intValue()), Types.OTHER);
        }
    }

    @Override
    public Object deepCopy(Object value) throws HibernateException {
        return value;
    }

    @Override
    public boolean isMutable() {
        return false;
    }

    @Override
    public Serializable disassemble(Object value) throws HibernateException {
        return (Serializable) value;
    }

    @Override
    public Object assemble(Serializable cached, Object owner)
            throws HibernateException {
        return cached;
    }

    @Override
    public Object replace(Object original, Object target, Object owner)
            throws HibernateException {
        return original;
    }

}
5
投票

您不必编写自己的 Hibernate 自定义类型即可将 PostgreSQL 

interval
列映射到 Java 
Duration
对象。您需要做的就是使用 Hibernate Ttypes 项目。

因此，添加适当的 Hibernate 依赖项后：

<dependency>
    <groupId>com.vladmihalcea</groupId>
    <artifactId>hibernate-types-52</artifactId>
    <version>2.6.0</version>
</dependency>

您只需使用 

@TypeDef
注释来注册 
PostgreSQLIntervalType
:

@Entity(name = "Book")
@Table(name = "book")
@TypeDef(
    typeClass = PostgreSQLIntervalType.class,
    defaultForType = Duration.class
)
@TypeDef(
    typeClass = YearMonthDateType.class,
    defaultForType = YearMonth.class
)
public class Book {
 
    @Id
    @GeneratedValue
    private Long id;
 
    @NaturalId
    private String isbn;
 
    private String title;
 
    @Column(
        name = "published_on",
        columnDefinition = "date"
    )
    private YearMonth publishedOn;
 
    @Column(
        name = "presale_period",
        columnDefinition = "interval"
    )
    private Duration presalePeriod;
 
    public Long getId() {
        return id;
    }
 
    public Book setId(Long id) {
        this.id = id;
        return this;
    }
 
    public String getIsbn() {
        return isbn;
    }
 
    public Book setIsbn(String isbn) {
        this.isbn = isbn;
        return this;
    }
 
    public String getTitle() {
        return title;
    }
 
    public Book setTitle(String title) {
        this.title = title;
        return this;
    }
 
    public YearMonth getPublishedOn() {
        return publishedOn;
    }
 
    public Book setPublishedOn(YearMonth publishedOn) {
        this.publishedOn = publishedOn;
        return this;
    }
 
    public Duration getPresalePeriod() {
        return presalePeriod;
    }
 
    public Book setPresalePeriod(Duration presalePeriod) {
        this.presalePeriod = presalePeriod;
        return this;
    }
}

现在，当持久化 

Book
实体时：

entityManager.persist(
    new Book()
        .setIsbn("978-9730228236")
        .setTitle("High-Performance Java Persistence")
        .setPublishedOn(YearMonth.of(2016, 10))
        .setPresalePeriod(
            Duration.between(
                LocalDate
                    .of(2015, Month.NOVEMBER, 2)
                    .atStartOfDay(),
                LocalDate
                    .of(2016, Month.AUGUST, 25)
                    .atStartOfDay()
            )
        )
);

Hibernate 将执行正确的 SQL INSERT 语句：

INSERT INTO book (
    isbn,
    presale_period,
    published_on,
    title,
    id
)
VALUES (
    '978-9730228236',
    '0 years 0 mons 297 days 0 hours 0 mins 0.00 secs',
    '2016-10-01',
    'High-Performance Java Persistence',
    1
)

当获取 

Book
实体时，我们可以看到 
Duration
属性已从数据库中正确获取：

Book book = entityManager
    .unwrap(Session.class)
    .bySimpleNaturalId(Book.class)
    .load("978-9730228236");
 
assertEquals(
    Duration.between(
        LocalDate
            .of(2015, Month.NOVEMBER, 2)
            .atStartOfDay(),
        LocalDate
            .of(2016, Month.AUGUST, 25)
            .atStartOfDay()
    ),
    book.getPresalePeriod()
);
2
投票

为什么不直接将其转换为数字并映射到 Long 呢？

SELECT EXTRACT(epoch FROM my_interval)
1
投票

PostgreSQL 有一个 date_part / extract 函数，您可以使用它返回不同的字段，纪元就是其中之一。从间隔中提取纪元时，您会收到间隔中包含的秒数，然后您可以根据需要进行转换。我失去了 Hibernate 的经验，但你可以这样做：

SELECT
    average_interval_between_airings
  , date_part('epoch', average_interval_between_airings) / 60 as minutes
  , date_part('epoch', average_interval_between_airings) as seconds
FROM shows;
0
投票

根据链接，您应该有一天，然后是小时：分钟：秒。因此，将代码更改为如下所示，假设您的时间间隔不需要超过 23 小时 59 分钟。

statement.setString(index, "'0 "+ hours +":" 
+ intervalFormat.format(minutes) + ":" 
+ intervalFormat.format(secondes)+"'");

我无法测试此代码，因为我没有安装 PostGreSql。有关同一问题的其他讨论，请参阅以下链接，尽管您必须修改提供的代码来处理秒数。不过这应该不是什么大问题。

https://forum.hibernate.org/viewtopic.php?p=2348558&sid=95488ce561e7efec8a2950f76ae4741c

0
投票

Hibernate 已经能够做到这一点已经有一段时间了。

休眠5

Hibernate 5 在 Java 方面对 

Duration
提供了本机支持，但它希望您将其存储在数据库中的“数字”列中，例如 
numeric
类型的列。它只会以十进制数的形式读取和写入 
Duration
值。 （带分数的秒数）。这是有道理的，因为通过这种策略，Hibernate 始终能够支持 
Duration
，无论目标数据库是否真正支持真正的 SQL INTERVAL 列类型。

休眠 6（当前）

现在对 PostgreSQL 

interval
列类型提供本机支持。 然而，由于历史原因（请阅读：不想破坏现有应用程序），您需要明确告诉 Hibernate 正在使用数据库的 SQL INTERVAL 功能（如果有）。如果您不这样做，那么 Hibernate 仍将像 v5 中那样执行操作，即它将尝试以小数形式写入列。显然，如果您的数据库是 PostgreSQL 并且您的列类型为 
interval
，那么这将不起作用。

您的实体类将如下所示：

@Entity
@Table(name = "mouse_observations")
public class MyTestEntity {
    ...

    @Column(name = "my_duration", columnDefinition = "interval")
    private Duration myDuration;
    ...
}

重要：

您需要设置属性 

hibernate.type.preferred_duration_jdbc_type=INTERVAL_SECOND
让 Hibernate 知道您正在使用数据库的 INTERVAL 类型。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.