java - 如何使用 jdbc/spring jdbc對PostgreSQL區間數據進行操作不使用 PGInterval?

  显示原文与译文双语对照的内容
0 0

java日期& time數據類型是眾所周知,所以無需關注。

但是,當我使用JDBC或基於Spring擴展,比如SimpleJdbcTemplate檢索和存儲 間隔值,Java類型應該使用什麼,如果我不想使用org postgre sql中.util .PGInterval類

此類為內部類的PostgreSQL驅動程序以使用它將特定於資料庫的代碼。 我覺得應當可以運行於指定時間間隔以資料庫不可知的方式,因為它是標準SQL類型之一。

时间: 原作者:

0 0

一個間隔不是標準分JDBC Types,中所列 java.sql.Typesclass 。 我知道如果調用 resultSet.getObject("interval_column"),它是一個 PGInterval當casted,所以看起來PG JDBC Driver可能強制你的手去處理它,,除非依Glenn所說的並將其轉換為string,或者是數字,在SQL中。

在我們的應用程序中,我們使用 JodaTime 給我們所有的日期管理,我們有" Hibernate Type我們bean屬性轉換為和轉換自編寫。 PGInterval,然後使用 getObjectsetObject與JDBC通信。 我懷疑這段代碼能幫你處理你想要的在這裡,但我可以跟你分享這些如果感興趣的話

Updated : 這是Hibernate Type類之間轉換Joda Time和PGInterval 。 我知道這不回答這個問題,但原始海報要的示例代碼。

package com.your.package.hibernate.types;

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

import org.hibernate.HibernateException;
import org.hibernate.usertype.UserType;
import org.joda.time.DurationFieldType;
import org.joda.time.Period;
import org.joda.time.ReadableDuration;
import org.joda.time.ReadablePeriod;
import org.postgresql.util.PGInterval;

public class JodaTimeDurationType
    implements UserType {

    public Class<?> returnedClass() {
        return ReadableDuration.class;
    }


    public int[] sqlTypes() {
        return new int[] {Types.OTHER};
    }


    public Object nullSafeGet(ResultSet resultSet, String[] names, Object owner)
        throws HibernateException, SQLException {

        try {
            final PGInterval pgi = (PGInterval)resultSet.getObject(names[0]);

            final int years = pgi.getYears();
            final int months = pgi.getMonths();
            final int days = pgi.getDays();
            final int hours = pgi.getHours();
            final int mins = pgi.getMinutes();
            final double secs = pgi.getSeconds();

            return new Period(years, months, 0, days, hours, mins, (int)secs, 0).toStandardDuration();

        }
        catch (Exception e) {
            return null;
        }
    }


    public void nullSafeSet(PreparedStatement statement, Object value, int index)
        throws HibernateException, SQLException {

        if (value == null) {
            statement.setNull(index, Types.OTHER);
        }
        else {
            final ReadablePeriod period = ((ReadableDuration)value).toPeriod();

            final int years = period.get(DurationFieldType.years());
            final int months = period.get(DurationFieldType.months());
            final int days = period.get(DurationFieldType.days());
            final int hours = period.get(DurationFieldType.hours());
            final int mins = period.get(DurationFieldType.minutes());
            final int secs = period.get(DurationFieldType.seconds());

            final PGInterval pgi = new PGInterval(years, months, days, hours, mins, secs);
            statement.setObject(index, pgi);
        }
    }


    public boolean equals(Object x, Object y)
        throws HibernateException {

        return x == y;
    }


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


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


    public boolean isMutable() {
        return false;
    }


    public Serializable disassemble(Object value)
        throws HibernateException {
        throw new HibernateException("not implemented");
    }


    public Object assemble(Serializable cached, Object owner)
        throws HibernateException {
        throw new HibernateException("not implemented");
    }


    public Object replace(Object original, Object target, Object owner)
        throws HibernateException {
        throw new HibernateException("not implemented");
    }
}
...