From 3c242dd05d28ada3f8065b74a33fc480136f84ea Mon Sep 17 00:00:00 2001
From: Lukas Eder <lukas.eder@gmail.com>
Date: Tue, 27 Mar 2012 16:25:22 +0000
Subject: [PATCH] [#566] Add support for INTERVAL data types - initial
 implementation for the Postgres dialect

---
 .../generatedclasses/test/tables/TDates.java  |   6 +-
 .../org/jooq/impl/DefaultBindContext.java     |  17 ++-
 .../java/org/jooq/impl/FieldTypeHelper.java   |  42 ++++--
 .../main/java/org/jooq/impl/SQLDataType.java  |   4 +-
 .../main/java/org/jooq/types/DayToSecond.java |  53 +++++++-
 .../main/java/org/jooq/types/YearToMonth.java |  16 +++
 .../org/jooq/util/oracle/OracleDataType.java  | 110 ++++++++--------
 .../util/postgres/PGIntervalConverter.java    |  88 +++++++++++++
 .../jooq/util/postgres/PostgresDataType.java  | 122 +++++++++---------
 9 files changed, 322 insertions(+), 136 deletions(-)
 create mode 100644 jOOQ/src/main/java/org/jooq/util/postgres/PGIntervalConverter.java

diff --git a/jOOQ-test/src/org/jooq/test/oracle/generatedclasses/test/tables/TDates.java b/jOOQ-test/src/org/jooq/test/oracle/generatedclasses/test/tables/TDates.java
index c6cca22177..0300356d65 100644
--- a/jOOQ-test/src/org/jooq/test/oracle/generatedclasses/test/tables/TDates.java
+++ b/jOOQ-test/src/org/jooq/test/oracle/generatedclasses/test/tables/TDates.java
@@ -8,7 +8,7 @@ package org.jooq.test.oracle.generatedclasses.test.tables;
  */
 public class TDates extends org.jooq.impl.UpdatableTableImpl<org.jooq.test.oracle.generatedclasses.test.tables.records.TDatesRecord> {
 
-	private static final long serialVersionUID = 2000943673;
+	private static final long serialVersionUID = -745318463;
 
 	/**
 	 * The singleton instance of TEST.T_DATES
@@ -63,12 +63,12 @@ public class TDates extends org.jooq.impl.UpdatableTableImpl<org.jooq.test.oracl
 	/**
 	 * An uncommented item
 	 */
-	public final org.jooq.TableField<org.jooq.test.oracle.generatedclasses.test.tables.records.TDatesRecord, org.jooq.types.YearToMonth> I_Y = createField("I_Y", org.jooq.impl.SQLDataType.INTERVAL_YEAR_TO_MONTH, this);
+	public final org.jooq.TableField<org.jooq.test.oracle.generatedclasses.test.tables.records.TDatesRecord, org.jooq.types.YearToMonth> I_Y = createField("I_Y", org.jooq.impl.SQLDataType.INTERVALYEARTOMONTH, this);
 
 	/**
 	 * An uncommented item
 	 */
-	public final org.jooq.TableField<org.jooq.test.oracle.generatedclasses.test.tables.records.TDatesRecord, org.jooq.types.DayToSecond> I_D = createField("I_D", org.jooq.impl.SQLDataType.INTERVAL_DAY_TO_SECOND, this);
+	public final org.jooq.TableField<org.jooq.test.oracle.generatedclasses.test.tables.records.TDatesRecord, org.jooq.types.DayToSecond> I_D = createField("I_D", org.jooq.impl.SQLDataType.INTERVALDAYTOSECOND, this);
 
 	/**
 	 * No further instances allowed
diff --git a/jOOQ/src/main/java/org/jooq/impl/DefaultBindContext.java b/jOOQ/src/main/java/org/jooq/impl/DefaultBindContext.java
index d2faf4a6e5..df718ce11c 100644
--- a/jOOQ/src/main/java/org/jooq/impl/DefaultBindContext.java
+++ b/jOOQ/src/main/java/org/jooq/impl/DefaultBindContext.java
@@ -40,6 +40,7 @@ import static org.jooq.SQLDialect.POSTGRES;
 import static org.jooq.SQLDialect.SQLITE;
 import static org.jooq.SQLDialect.SQLSERVER;
 import static org.jooq.SQLDialect.SYBASE;
+import static org.jooq.util.postgres.PGIntervalConverter.toPGInterval;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -221,13 +222,23 @@ class DefaultBindContext extends AbstractBindContext {
         else if (type == Timestamp.class) {
             stmt.setTimestamp(nextIndex(), (Timestamp) value);
         }
-        
+
         // [#566] Interval data types are best bound as Strings
         else if (type == YearToMonth.class) {
-            stmt.setString(nextIndex(), value.toString());
+            if (dialect == POSTGRES) {
+                stmt.setObject(nextIndex(), toPGInterval((YearToMonth) value));
+            }
+            else {
+                stmt.setString(nextIndex(), value.toString());
+            }
         }
         else if (type == DayToSecond.class) {
-            stmt.setString(nextIndex(), value.toString());
+            if (dialect == POSTGRES) {
+                stmt.setObject(nextIndex(), toPGInterval((DayToSecond) value));
+            }
+            else {
+                stmt.setString(nextIndex(), value.toString());
+            }
         }
         else if (UNumber.class.isAssignableFrom(type)) {
             stmt.setString(nextIndex(), value.toString());
diff --git a/jOOQ/src/main/java/org/jooq/impl/FieldTypeHelper.java b/jOOQ/src/main/java/org/jooq/impl/FieldTypeHelper.java
index 0b266fd900..63cb9fce8c 100644
--- a/jOOQ/src/main/java/org/jooq/impl/FieldTypeHelper.java
+++ b/jOOQ/src/main/java/org/jooq/impl/FieldTypeHelper.java
@@ -36,6 +36,7 @@
 
 package org.jooq.impl;
 
+import static org.jooq.SQLDialect.POSTGRES;
 import static org.jooq.impl.Factory.getNewFactory;
 
 import java.math.BigDecimal;
@@ -87,6 +88,7 @@ import org.jooq.util.hsqldb.HSQLDBDataType;
 import org.jooq.util.ingres.IngresDataType;
 import org.jooq.util.mysql.MySQLDataType;
 import org.jooq.util.oracle.OracleDataType;
+import org.jooq.util.postgres.PGIntervalConverter;
 import org.jooq.util.postgres.PGobjectParser;
 import org.jooq.util.postgres.PostgresDataType;
 import org.jooq.util.sqlite.SQLiteDataType;
@@ -380,12 +382,24 @@ public final class FieldTypeHelper {
             return (T) getTimestamp(ctx.getDialect(), rs, index);
         }
         else if (type == YearToMonth.class) {
-            String string = rs.getString(index);
-            return (T) (string == null ? null : YearToMonth.valueOf(string));
+            if (ctx.getDialect() == POSTGRES) {
+                Object object = rs.getObject(index);
+                return (T) (object == null ? null : PGIntervalConverter.toYearToMonth(object));
+            }
+            else {
+                String string = rs.getString(index);
+                return (T) (string == null ? null : YearToMonth.valueOf(string));
+            }
         }
         else if (type == DayToSecond.class) {
-            String string = rs.getString(index);
-            return (T) (string == null ? null : DayToSecond.valueOf(string));
+            if (ctx.getDialect() == POSTGRES) {
+                Object object = rs.getObject(index);
+                return (T) (object == null ? null : PGIntervalConverter.toDayToSecond(object));
+            }
+            else {
+                String string = rs.getString(index);
+                return (T) (string == null ? null : DayToSecond.valueOf(string));
+            }
         }
         else if (type == UByte.class) {
             String string = rs.getString(index);
@@ -653,12 +667,24 @@ public final class FieldTypeHelper {
             return (T) stmt.getTimestamp(index);
         }
         else if (type == YearToMonth.class) {
-            String string = stmt.getString(index);
-            return (T) (string == null ? null : YearToMonth.valueOf(string));
+            if (ctx.getDialect() == POSTGRES) {
+                Object object = stmt.getObject(index);
+                return (T) (object == null ? null : PGIntervalConverter.toYearToMonth(object));
+            }
+            else {
+                String string = stmt.getString(index);
+                return (T) (string == null ? null : YearToMonth.valueOf(string));
+            }
         }
         else if (type == DayToSecond.class) {
-            String string = stmt.getString(index);
-            return (T) (string == null ? null : DayToSecond.valueOf(string));
+            if (ctx.getDialect() == POSTGRES) {
+                Object object = stmt.getObject(index);
+                return (T) (object == null ? null : PGIntervalConverter.toDayToSecond(object));
+            }
+            else {
+                String string = stmt.getString(index);
+                return (T) (string == null ? null : DayToSecond.valueOf(string));
+            }
         }
         else if (type == UByte.class) {
             String string = stmt.getString(index);
diff --git a/jOOQ/src/main/java/org/jooq/impl/SQLDataType.java b/jOOQ/src/main/java/org/jooq/impl/SQLDataType.java
index a9bc299ddb..51cc593b80 100644
--- a/jOOQ/src/main/java/org/jooq/impl/SQLDataType.java
+++ b/jOOQ/src/main/java/org/jooq/impl/SQLDataType.java
@@ -250,12 +250,12 @@ public final class SQLDataType<T> extends AbstractDataType<T> {
     /**
      * The SQL standard <code>INTERVAL YEAR TO MONTH</code> data type
      */
-    public static final SQLDataType<YearToMonth> INTERVAL_YEAR_TO_MONTH = new SQLDataType<YearToMonth>(YearToMonth.class, "interval_year_to_month");
+    public static final SQLDataType<YearToMonth> INTERVALYEARTOMONTH = new SQLDataType<YearToMonth>(YearToMonth.class, "interval year to month");
 
     /**
      * The SQL standard <code>INTERVAL DAY TO SECOND</code> data type
      */
-    public static final SQLDataType<DayToSecond> INTERVAL_DAY_TO_SECOND = new SQLDataType<DayToSecond>(DayToSecond.class, "interval_day_to_second");
+    public static final SQLDataType<DayToSecond> INTERVALDAYTOSECOND = new SQLDataType<DayToSecond>(DayToSecond.class, "interval day to second");
 
     // -------------------------------------------------------------------------
     // Binary types
diff --git a/jOOQ/src/main/java/org/jooq/types/DayToSecond.java b/jOOQ/src/main/java/org/jooq/types/DayToSecond.java
index 58be33f5b7..184f2f6ae5 100644
--- a/jOOQ/src/main/java/org/jooq/types/DayToSecond.java
+++ b/jOOQ/src/main/java/org/jooq/types/DayToSecond.java
@@ -38,6 +38,7 @@ package org.jooq.types;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import org.jooq.tools.Convert;
 import org.jooq.tools.StringUtils;
 
 /**
@@ -53,7 +54,7 @@ public final class DayToSecond implements Interval<DayToSecond> {
      * Generated UID
      */
     private static final long    serialVersionUID = -3853596481984643811L;
-    private static final Pattern PATTERN          = Pattern.compile("(\\+|-)?(\\d+) (\\d+):(\\d+):(\\d+)\\.(\\d+)");
+    private static final Pattern PATTERN          = Pattern.compile("(\\+|-)?(?:(\\d+) )?(\\d+):(\\d+):(\\d+)(?:\\.(\\d+))?");
 
     private final boolean        negative;
     private final int            days;
@@ -98,6 +99,26 @@ public final class DayToSecond implements Interval<DayToSecond> {
     }
 
     private DayToSecond(int days, int hours, int minutes, int seconds, int nano, boolean negative) {
+
+        // Perform normalisation. Specifically, Postgres may return intervals
+        // such as 24:00:00, 25:13:15, etc...
+        if (nano >= 1000000000) {
+            seconds += (nano / 1000000000);
+            nano %= 1000000000;
+        }
+        if (seconds >= 60) {
+            minutes += (seconds / 60);
+            seconds %= 60;
+        }
+        if (minutes >= 60) {
+            hours += (minutes / 60);
+            minutes %= 60;
+        }
+        if (hours >= 24) {
+            days += (hours / 24);
+            hours %= 24;
+        }
+
         this.negative = negative;
         this.days = days;
         this.hours = hours;
@@ -120,11 +141,11 @@ public final class DayToSecond implements Interval<DayToSecond> {
 
             if (matcher.find()) {
                 boolean negative = "-".equals(matcher.group(1));
-                int days = Integer.parseInt(matcher.group(2));
-                int hours = Integer.parseInt(matcher.group(3));
-                int minutes = Integer.parseInt(matcher.group(4));
-                int seconds = Integer.parseInt(matcher.group(5));
-                int nano = Integer.parseInt(StringUtils.rightPad(matcher.group(6), 9, "0"));
+                int days = Convert.convert(matcher.group(2), int.class);
+                int hours = Convert.convert(matcher.group(3), int.class);
+                int minutes = Convert.convert(matcher.group(4), int.class);
+                int seconds = Convert.convert(matcher.group(5), int.class);
+                int nano = Convert.convert(StringUtils.rightPad(matcher.group(6), 9, "0"), int.class);
 
                 return new DayToSecond(days, hours, minutes, seconds, nano, negative);
             }
@@ -147,6 +168,26 @@ public final class DayToSecond implements Interval<DayToSecond> {
         return new DayToSecond(days, hours, minutes, seconds, nano, false);
     }
 
+    public final int getDays() {
+        return days;
+    }
+
+    public final int getHours() {
+        return hours;
+    }
+
+    public final int getMinutes() {
+        return minutes;
+    }
+
+    public final int getSeconds() {
+        return seconds;
+    }
+
+    public final int getNano() {
+        return nano;
+    }
+
     // -------------------------------------------------------------------------
     // XXX Comparable and Object API
     // -------------------------------------------------------------------------
diff --git a/jOOQ/src/main/java/org/jooq/types/YearToMonth.java b/jOOQ/src/main/java/org/jooq/types/YearToMonth.java
index 29ade2329e..5f87558e29 100644
--- a/jOOQ/src/main/java/org/jooq/types/YearToMonth.java
+++ b/jOOQ/src/main/java/org/jooq/types/YearToMonth.java
@@ -72,6 +72,14 @@ public final class YearToMonth implements Interval<YearToMonth> {
     }
 
     private YearToMonth(int years, int months, boolean negative) {
+
+        // Perform normalisation. Specifically, Postgres may return intervals
+        // such as 0-13
+        if (months >= 12) {
+            years += (months / 12);
+            months %= 12;
+        }
+
         this.negative = negative;
         this.years = years;
         this.months = months;
@@ -115,6 +123,14 @@ public final class YearToMonth implements Interval<YearToMonth> {
         return new YearToMonth(years, months, false);
     }
 
+    public final int getYears() {
+        return years;
+    }
+
+    public final int getMonths() {
+        return months;
+    }
+
     // -------------------------------------------------------------------------
     // XXX Comparable and Object API
     // -------------------------------------------------------------------------
diff --git a/jOOQ/src/main/java/org/jooq/util/oracle/OracleDataType.java b/jOOQ/src/main/java/org/jooq/util/oracle/OracleDataType.java
index 4224453854..5ff729f07c 100644
--- a/jOOQ/src/main/java/org/jooq/util/oracle/OracleDataType.java
+++ b/jOOQ/src/main/java/org/jooq/util/oracle/OracleDataType.java
@@ -62,84 +62,84 @@ public class OracleDataType<T> extends AbstractDataType<T> {
     /**
      * Generated UID
      */
-    private static final long                      serialVersionUID       = -5677365115109672781L;
+    private static final long                        serialVersionUID       = -5677365115109672781L;
 
     // -------------------------------------------------------------------------
     // Default SQL data types and synonyms thereof
     // -------------------------------------------------------------------------
 
-    public static final OracleDataType<BigDecimal> NUMBER                 = new OracleDataType<BigDecimal>(SQLDataType.NUMERIC, "number", true);
-    public static final OracleDataType<BigDecimal> NUMERIC                = new OracleDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric", true);
-    public static final OracleDataType<BigDecimal> DECIMAL                = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal", true);
-    public static final OracleDataType<BigDecimal> DEC                    = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "dec", true);
-    public static final OracleDataType<String>     VARCHAR2               = new OracleDataType<String>(SQLDataType.VARCHAR, "varchar2", "varchar2(4000)");
-    public static final OracleDataType<String>     VARCHAR                = new OracleDataType<String>(SQLDataType.VARCHAR, "varchar", "varchar2(4000)");
-    public static final OracleDataType<String>     CHAR                   = new OracleDataType<String>(SQLDataType.CHAR, "char", "varchar2(4000)");
-    public static final OracleDataType<String>     CLOB                   = new OracleDataType<String>(SQLDataType.CLOB, "clob");
-    public static final OracleDataType<String>     NVARCHAR2              = new OracleDataType<String>(SQLDataType.NVARCHAR, "nvarchar2", "varchar2(4000)");
-    public static final OracleDataType<String>     NVARCHAR               = new OracleDataType<String>(SQLDataType.NVARCHAR, "nvarchar", "varchar2(4000)");
-    public static final OracleDataType<String>     NCHAR                  = new OracleDataType<String>(SQLDataType.NCHAR, "nchar", "varchar2(4000)");
-    public static final OracleDataType<String>     NCLOB                  = new OracleDataType<String>(SQLDataType.NCLOB, "nclob");
-    public static final OracleDataType<Date>       DATE                   = new OracleDataType<Date>(SQLDataType.DATE, "date");
-    public static final OracleDataType<Timestamp>  TIMESTAMP              = new OracleDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
-    public static final OracleDataType<byte[]>     BLOB                   = new OracleDataType<byte[]>(SQLDataType.BLOB, "blob");
-    public static final OracleDataType<YearToMonth>  INTERVALYEARTOMONTH    = new OracleDataType<YearToMonth>(SQLDataType.INTERVAL_YEAR_TO_MONTH, "interval year to month");
-    public static final OracleDataType<DayToSecond>  INTERVALDAYTOSECOND    = new OracleDataType<DayToSecond>(SQLDataType.INTERVAL_DAY_TO_SECOND, "interval day to second");
+    public static final OracleDataType<BigDecimal>   NUMBER                 = new OracleDataType<BigDecimal>(SQLDataType.NUMERIC, "number", true);
+    public static final OracleDataType<BigDecimal>   NUMERIC                = new OracleDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric", true);
+    public static final OracleDataType<BigDecimal>   DECIMAL                = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal", true);
+    public static final OracleDataType<BigDecimal>   DEC                    = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "dec", true);
+    public static final OracleDataType<String>       VARCHAR2               = new OracleDataType<String>(SQLDataType.VARCHAR, "varchar2", "varchar2(4000)");
+    public static final OracleDataType<String>       VARCHAR                = new OracleDataType<String>(SQLDataType.VARCHAR, "varchar", "varchar2(4000)");
+    public static final OracleDataType<String>       CHAR                   = new OracleDataType<String>(SQLDataType.CHAR, "char", "varchar2(4000)");
+    public static final OracleDataType<String>       CLOB                   = new OracleDataType<String>(SQLDataType.CLOB, "clob");
+    public static final OracleDataType<String>       NVARCHAR2              = new OracleDataType<String>(SQLDataType.NVARCHAR, "nvarchar2", "varchar2(4000)");
+    public static final OracleDataType<String>       NVARCHAR               = new OracleDataType<String>(SQLDataType.NVARCHAR, "nvarchar", "varchar2(4000)");
+    public static final OracleDataType<String>       NCHAR                  = new OracleDataType<String>(SQLDataType.NCHAR, "nchar", "varchar2(4000)");
+    public static final OracleDataType<String>       NCLOB                  = new OracleDataType<String>(SQLDataType.NCLOB, "nclob");
+    public static final OracleDataType<Date>         DATE                   = new OracleDataType<Date>(SQLDataType.DATE, "date");
+    public static final OracleDataType<Timestamp>    TIMESTAMP              = new OracleDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
+    public static final OracleDataType<byte[]>       BLOB                   = new OracleDataType<byte[]>(SQLDataType.BLOB, "blob");
+    public static final OracleDataType<YearToMonth>  INTERVALYEARTOMONTH    = new OracleDataType<YearToMonth>(SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
+    public static final OracleDataType<DayToSecond>  INTERVALDAYTOSECOND    = new OracleDataType<DayToSecond>(SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
 
     // -------------------------------------------------------------------------
     // Compatibility types for supported SQLDataTypes
     // -------------------------------------------------------------------------
 
-    protected static final OracleDataType<byte[]>  __BINARY               = new OracleDataType<byte[]>(SQLDataType.BINARY, "blob");
-    protected static final OracleDataType<Long>    __BIGINT               = new OracleDataType<Long>(SQLDataType.BIGINT, "number", "number(19)");
-    protected static final OracleDataType<Boolean> __BIT                  = new OracleDataType<Boolean>(SQLDataType.BIT, "number", "number(1)");
-    protected static final OracleDataType<Boolean> __BOOLEAN              = new OracleDataType<Boolean>(SQLDataType.BOOLEAN, "number", "number(1)");
-    protected static final OracleDataType<Double>  __DOUBLE               = new OracleDataType<Double>(SQLDataType.DOUBLE, "number");
-    protected static final OracleDataType<Double>  __FLOAT                = new OracleDataType<Double>(SQLDataType.FLOAT, "number");
-    protected static final OracleDataType<Integer> __INTEGER              = new OracleDataType<Integer>(SQLDataType.INTEGER, "number", "number(10)");
-    protected static final OracleDataType<byte[]>  __LONGVARBINARY        = new OracleDataType<byte[]>(SQLDataType.LONGVARBINARY, "blob");
-    protected static final OracleDataType<String>  __LONGVARCHAR          = new OracleDataType<String>(SQLDataType.LONGVARCHAR, "varchar2", "varchar2(4000)");
-    protected static final OracleDataType<String>  __LONGNVARCHAR         = new OracleDataType<String>(SQLDataType.LONGNVARCHAR, "varchar2", "varchar2(4000)");
-    protected static final OracleDataType<Float>   __REAL                 = new OracleDataType<Float>(SQLDataType.REAL, "number");
-    protected static final OracleDataType<Short>   __SMALLINT             = new OracleDataType<Short>(SQLDataType.SMALLINT, "number", "number(5)");
-    protected static final OracleDataType<Time>    __TIME                 = new OracleDataType<Time>(SQLDataType.TIME, "timestamp");
-    protected static final OracleDataType<Byte>    __TINYINT              = new OracleDataType<Byte>(SQLDataType.TINYINT, "number", "number(3)");
-    protected static final OracleDataType<byte[]>  __VARBINARY            = new OracleDataType<byte[]>(SQLDataType.VARBINARY, "blob");
+    protected static final OracleDataType<byte[]>    __BINARY               = new OracleDataType<byte[]>(SQLDataType.BINARY, "blob");
+    protected static final OracleDataType<Long>      __BIGINT               = new OracleDataType<Long>(SQLDataType.BIGINT, "number", "number(19)");
+    protected static final OracleDataType<Boolean>   __BIT                  = new OracleDataType<Boolean>(SQLDataType.BIT, "number", "number(1)");
+    protected static final OracleDataType<Boolean>   __BOOLEAN              = new OracleDataType<Boolean>(SQLDataType.BOOLEAN, "number", "number(1)");
+    protected static final OracleDataType<Double>    __DOUBLE               = new OracleDataType<Double>(SQLDataType.DOUBLE, "number");
+    protected static final OracleDataType<Double>    __FLOAT                = new OracleDataType<Double>(SQLDataType.FLOAT, "number");
+    protected static final OracleDataType<Integer>   __INTEGER              = new OracleDataType<Integer>(SQLDataType.INTEGER, "number", "number(10)");
+    protected static final OracleDataType<byte[]>    __LONGVARBINARY        = new OracleDataType<byte[]>(SQLDataType.LONGVARBINARY, "blob");
+    protected static final OracleDataType<String>    __LONGVARCHAR          = new OracleDataType<String>(SQLDataType.LONGVARCHAR, "varchar2", "varchar2(4000)");
+    protected static final OracleDataType<String>    __LONGNVARCHAR         = new OracleDataType<String>(SQLDataType.LONGNVARCHAR, "varchar2", "varchar2(4000)");
+    protected static final OracleDataType<Float>     __REAL                 = new OracleDataType<Float>(SQLDataType.REAL, "number");
+    protected static final OracleDataType<Short>     __SMALLINT             = new OracleDataType<Short>(SQLDataType.SMALLINT, "number", "number(5)");
+    protected static final OracleDataType<Time>      __TIME                 = new OracleDataType<Time>(SQLDataType.TIME, "timestamp");
+    protected static final OracleDataType<Byte>      __TINYINT              = new OracleDataType<Byte>(SQLDataType.TINYINT, "number", "number(3)");
+    protected static final OracleDataType<byte[]>    __VARBINARY            = new OracleDataType<byte[]>(SQLDataType.VARBINARY, "blob");
 
     // -------------------------------------------------------------------------
     // Compatibility types for supported Java types
     // -------------------------------------------------------------------------
 
-    protected static final OracleDataType<BigInteger> __BIGINTEGER        = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "number");
+    protected static final OracleDataType<BigInteger>   __BIGINTEGER        = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "number");
 
     // -------------------------------------------------------------------------
     // Dialect-specific data types and synonyms thereof
     // -------------------------------------------------------------------------
 
-    public static final OracleDataType<Result<Record>> REF_CURSOR         = new OracleDataType<Result<Record>>(SQLDataType.RESULT, "ref cursor");
+    public static final OracleDataType<Result<Record>>  REF_CURSOR          = new OracleDataType<Result<Record>>(SQLDataType.RESULT, "ref cursor");
 
-    public static final OracleDataType<String>     LONG                   = new OracleDataType<String>(SQLDataType.CLOB, "long");
-    public static final OracleDataType<byte[]>     RAW                    = new OracleDataType<byte[]>(SQLDataType.BLOB, "raw");
-    public static final OracleDataType<byte[]>     LONGRAW                = new OracleDataType<byte[]>(SQLDataType.BLOB, "longraw");
-    public static final OracleDataType<byte[]>     BFILE                  = new OracleDataType<byte[]>(SQLDataType.BLOB, "bfile");
+    public static final OracleDataType<String>       LONG                   = new OracleDataType<String>(SQLDataType.CLOB, "long");
+    public static final OracleDataType<byte[]>       RAW                    = new OracleDataType<byte[]>(SQLDataType.BLOB, "raw");
+    public static final OracleDataType<byte[]>       LONGRAW                = new OracleDataType<byte[]>(SQLDataType.BLOB, "longraw");
+    public static final OracleDataType<byte[]>       BFILE                  = new OracleDataType<byte[]>(SQLDataType.BLOB, "bfile");
 
     // PL/SQL data types
-    public static final OracleDataType<Integer>    BINARY_INTEGER         = new OracleDataType<Integer>(SQLDataType.INTEGER, "binary_integer");
-    public static final OracleDataType<Integer>    PLS_INTEGER            = new OracleDataType<Integer>(SQLDataType.INTEGER, "pls_integer");
-    public static final OracleDataType<Integer>    NATURAL                = new OracleDataType<Integer>(SQLDataType.INTEGER, "natural");
-    public static final OracleDataType<Integer>    NATURALN               = new OracleDataType<Integer>(SQLDataType.INTEGER, "naturaln");
-    public static final OracleDataType<Integer>    POSITIVE               = new OracleDataType<Integer>(SQLDataType.INTEGER, "positive");
-    public static final OracleDataType<Integer>    POSITIVEN              = new OracleDataType<Integer>(SQLDataType.INTEGER, "positiven");
-    public static final OracleDataType<Integer>    SIGNTYPE               = new OracleDataType<Integer>(SQLDataType.INTEGER, "signtype");
-    public static final OracleDataType<Double>     REAL                   = new OracleDataType<Double>(SQLDataType.DOUBLE, "real");
-    public static final OracleDataType<Double>     DOUBLE_PRECISION       = new OracleDataType<Double>(SQLDataType.DOUBLE, "double_precision");
-    public static final OracleDataType<Double>     BINARY_DOUBLE          = new OracleDataType<Double>(SQLDataType.DOUBLE, "binary_double");
-    public static final OracleDataType<BigDecimal> FLOAT                  = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "float");
-    public static final OracleDataType<BigDecimal> BINARY_FLOAT           = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "binary_float");
-    public static final OracleDataType<BigInteger> INTEGER                = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "integer");
-    public static final OracleDataType<BigInteger> INT                    = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "int");
-    public static final OracleDataType<BigInteger> SMALLINT               = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "smallint");
-    public static final OracleDataType<Boolean>    BOOLEAN                = new OracleDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
+    public static final OracleDataType<Integer>      BINARY_INTEGER         = new OracleDataType<Integer>(SQLDataType.INTEGER, "binary_integer");
+    public static final OracleDataType<Integer>      PLS_INTEGER            = new OracleDataType<Integer>(SQLDataType.INTEGER, "pls_integer");
+    public static final OracleDataType<Integer>      NATURAL                = new OracleDataType<Integer>(SQLDataType.INTEGER, "natural");
+    public static final OracleDataType<Integer>      NATURALN               = new OracleDataType<Integer>(SQLDataType.INTEGER, "naturaln");
+    public static final OracleDataType<Integer>      POSITIVE               = new OracleDataType<Integer>(SQLDataType.INTEGER, "positive");
+    public static final OracleDataType<Integer>      POSITIVEN              = new OracleDataType<Integer>(SQLDataType.INTEGER, "positiven");
+    public static final OracleDataType<Integer>      SIGNTYPE               = new OracleDataType<Integer>(SQLDataType.INTEGER, "signtype");
+    public static final OracleDataType<Double>       REAL                   = new OracleDataType<Double>(SQLDataType.DOUBLE, "real");
+    public static final OracleDataType<Double>       DOUBLE_PRECISION       = new OracleDataType<Double>(SQLDataType.DOUBLE, "double_precision");
+    public static final OracleDataType<Double>       BINARY_DOUBLE          = new OracleDataType<Double>(SQLDataType.DOUBLE, "binary_double");
+    public static final OracleDataType<BigDecimal>   FLOAT                  = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "float");
+    public static final OracleDataType<BigDecimal>   BINARY_FLOAT           = new OracleDataType<BigDecimal>(SQLDataType.DECIMAL, "binary_float");
+    public static final OracleDataType<BigInteger>   INTEGER                = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "integer");
+    public static final OracleDataType<BigInteger>   INT                    = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "int");
+    public static final OracleDataType<BigInteger>   SMALLINT               = new OracleDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "smallint");
+    public static final OracleDataType<Boolean>      BOOLEAN                = new OracleDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
 
     private OracleDataType(SQLDataType<T> sqlDataType, String typeName) {
         this(sqlDataType, typeName, false);
diff --git a/jOOQ/src/main/java/org/jooq/util/postgres/PGIntervalConverter.java b/jOOQ/src/main/java/org/jooq/util/postgres/PGIntervalConverter.java
new file mode 100644
index 0000000000..7ebd903f9a
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/util/postgres/PGIntervalConverter.java
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2009-2012, Lukas Eder, lukas.eder@gmail.com
+ * All rights reserved.
+ *
+ * This software is licensed to you under the Apache License, Version 2.0
+ * (the "License"); You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * . Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * . Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * . Neither the name "jOOQ" nor the names of its contributors may be
+ *   used to endorse or promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.jooq.util.postgres;
+
+import static org.jooq.tools.reflect.Reflect.on;
+
+import org.jooq.tools.reflect.Reflect;
+import org.jooq.types.DayToSecond;
+import org.jooq.types.YearToMonth;
+
+/**
+ * A converter for <code>org.postgresql.util.PGInterval</code>
+ * <p>
+ * Postgres returns an undisclosed internal type for intervals. This converter
+ * takes care of converting the internal type to jOOQ's interval data types
+ * {@link DayToSecond} and {@link YearToMonth}
+ *
+ * @author Lukas Eder
+ */
+public class PGIntervalConverter {
+
+    public static Object toPGInterval(DayToSecond interval) {
+        return on("org.postgresql.util.PGInterval").create(0, 0,
+            interval.getDays(),
+            interval.getHours(),
+            interval.getMinutes(),
+            interval.getSeconds() +
+            interval.getNano() / 1000000000.0).get();
+    }
+
+    public static Object toPGInterval(YearToMonth interval) {
+        return on("org.postgresql.util.PGInterval").create(
+            interval.getYears(),
+            interval.getMonths(),
+            0, 0, 0, 0.0).get();
+    }
+
+    public static DayToSecond toDayToSecond(Object pgInterval) {
+        Reflect i = on(pgInterval);
+        Double seconds = i.call("getSeconds").<Double>get();
+        return new DayToSecond(
+            i.call("getDays").<Integer>get(),
+            i.call("getHours").<Integer>get(),
+            i.call("getMinutes").<Integer>get(),
+            seconds.intValue(),
+            (int) (1000000000 * (seconds - seconds.intValue())));
+    }
+
+    public static YearToMonth toYearToMonth(Object pgInterval) {
+        Reflect i = on(pgInterval);
+        return new YearToMonth(
+            i.call("getYears").<Integer>get(),
+            i.call("getMonths").<Integer>get());
+    }
+}
diff --git a/jOOQ/src/main/java/org/jooq/util/postgres/PostgresDataType.java b/jOOQ/src/main/java/org/jooq/util/postgres/PostgresDataType.java
index 8c2b7cdfe0..c9b8bb5b4b 100644
--- a/jOOQ/src/main/java/org/jooq/util/postgres/PostgresDataType.java
+++ b/jOOQ/src/main/java/org/jooq/util/postgres/PostgresDataType.java
@@ -48,6 +48,8 @@ import org.jooq.Result;
 import org.jooq.SQLDialect;
 import org.jooq.impl.AbstractDataType;
 import org.jooq.impl.SQLDataType;
+import org.jooq.types.DayToSecond;
+import org.jooq.types.YearToMonth;
 
 /**
  * Supported data types for the {@link SQLDialect#POSTGRES} dialect
@@ -66,82 +68,84 @@ public class PostgresDataType<T> extends AbstractDataType<T> {
     // Default SQL data types and synonyms thereof
     // -------------------------------------------------------------------------
 
-    public static final PostgresDataType<Short>      SMALLINT                 = new PostgresDataType<Short>(SQLDataType.SMALLINT, "smallint");
-    public static final PostgresDataType<Short>      INT2                     = new PostgresDataType<Short>(SQLDataType.SMALLINT, "int2");
-    public static final PostgresDataType<Integer>    INT                      = new PostgresDataType<Integer>(SQLDataType.INTEGER, "int");
-    public static final PostgresDataType<Integer>    INTEGER                  = new PostgresDataType<Integer>(SQLDataType.INTEGER, "integer");
-    public static final PostgresDataType<Integer>    INT4                     = new PostgresDataType<Integer>(SQLDataType.INTEGER, "int4");
-    public static final PostgresDataType<Long>       BIGINT                   = new PostgresDataType<Long>(SQLDataType.BIGINT, "bigint");
-    public static final PostgresDataType<Long>       INT8                     = new PostgresDataType<Long>(SQLDataType.BIGINT, "int8");
-    public static final PostgresDataType<Double>     DOUBLEPRECISION          = new PostgresDataType<Double>(SQLDataType.DOUBLE, "double precision");
-    public static final PostgresDataType<Double>     FLOAT8                   = new PostgresDataType<Double>(SQLDataType.FLOAT, "float8");
-    public static final PostgresDataType<Float>      REAL                     = new PostgresDataType<Float>(SQLDataType.REAL, "real");
-    public static final PostgresDataType<Float>      FLOAT4                   = new PostgresDataType<Float>(SQLDataType.REAL, "float4");
-    public static final PostgresDataType<Boolean>    BOOLEAN                  = new PostgresDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
-    public static final PostgresDataType<Boolean>    BOOL                     = new PostgresDataType<Boolean>(SQLDataType.BOOLEAN, "bool");
-    public static final PostgresDataType<BigDecimal> NUMERIC                  = new PostgresDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
-    public static final PostgresDataType<BigDecimal> DECIMAL                  = new PostgresDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
-    public static final PostgresDataType<String>     VARCHAR                  = new PostgresDataType<String>(SQLDataType.VARCHAR, "varchar");
-    public static final PostgresDataType<String>     CHARACTERVARYING         = new PostgresDataType<String>(SQLDataType.VARCHAR, "character varying");
-    public static final PostgresDataType<String>     CHAR                     = new PostgresDataType<String>(SQLDataType.CHAR, "char");
-    public static final PostgresDataType<String>     CHARACTER                = new PostgresDataType<String>(SQLDataType.CHAR, "character");
-    public static final PostgresDataType<String>     TEXT                     = new PostgresDataType<String>(SQLDataType.CLOB, "text");
-    public static final PostgresDataType<Date>       DATE                     = new PostgresDataType<Date>(SQLDataType.DATE, "date");
-    public static final PostgresDataType<Time>       TIME                     = new PostgresDataType<Time>(SQLDataType.TIME, "time");
-    public static final PostgresDataType<Timestamp>  TIMESTAMP                = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
-    public static final PostgresDataType<byte[]>     BYTEA                    = new PostgresDataType<byte[]>(SQLDataType.BLOB, "bytea");
+    public static final PostgresDataType<Short>        SMALLINT                 = new PostgresDataType<Short>(SQLDataType.SMALLINT, "smallint");
+    public static final PostgresDataType<Short>        INT2                     = new PostgresDataType<Short>(SQLDataType.SMALLINT, "int2");
+    public static final PostgresDataType<Integer>      INT                      = new PostgresDataType<Integer>(SQLDataType.INTEGER, "int");
+    public static final PostgresDataType<Integer>      INTEGER                  = new PostgresDataType<Integer>(SQLDataType.INTEGER, "integer");
+    public static final PostgresDataType<Integer>      INT4                     = new PostgresDataType<Integer>(SQLDataType.INTEGER, "int4");
+    public static final PostgresDataType<Long>         BIGINT                   = new PostgresDataType<Long>(SQLDataType.BIGINT, "bigint");
+    public static final PostgresDataType<Long>         INT8                     = new PostgresDataType<Long>(SQLDataType.BIGINT, "int8");
+    public static final PostgresDataType<Double>       DOUBLEPRECISION          = new PostgresDataType<Double>(SQLDataType.DOUBLE, "double precision");
+    public static final PostgresDataType<Double>       FLOAT8                   = new PostgresDataType<Double>(SQLDataType.FLOAT, "float8");
+    public static final PostgresDataType<Float>        REAL                     = new PostgresDataType<Float>(SQLDataType.REAL, "real");
+    public static final PostgresDataType<Float>        FLOAT4                   = new PostgresDataType<Float>(SQLDataType.REAL, "float4");
+    public static final PostgresDataType<Boolean>      BOOLEAN                  = new PostgresDataType<Boolean>(SQLDataType.BOOLEAN, "boolean");
+    public static final PostgresDataType<Boolean>      BOOL                     = new PostgresDataType<Boolean>(SQLDataType.BOOLEAN, "bool");
+    public static final PostgresDataType<BigDecimal>   NUMERIC                  = new PostgresDataType<BigDecimal>(SQLDataType.NUMERIC, "numeric");
+    public static final PostgresDataType<BigDecimal>   DECIMAL                  = new PostgresDataType<BigDecimal>(SQLDataType.DECIMAL, "decimal");
+    public static final PostgresDataType<String>       VARCHAR                  = new PostgresDataType<String>(SQLDataType.VARCHAR, "varchar");
+    public static final PostgresDataType<String>       CHARACTERVARYING         = new PostgresDataType<String>(SQLDataType.VARCHAR, "character varying");
+    public static final PostgresDataType<String>       CHAR                     = new PostgresDataType<String>(SQLDataType.CHAR, "char");
+    public static final PostgresDataType<String>       CHARACTER                = new PostgresDataType<String>(SQLDataType.CHAR, "character");
+    public static final PostgresDataType<String>       TEXT                     = new PostgresDataType<String>(SQLDataType.CLOB, "text");
+    public static final PostgresDataType<Date>         DATE                     = new PostgresDataType<Date>(SQLDataType.DATE, "date");
+    public static final PostgresDataType<Time>         TIME                     = new PostgresDataType<Time>(SQLDataType.TIME, "time");
+    public static final PostgresDataType<Timestamp>    TIMESTAMP                = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp");
+    public static final PostgresDataType<byte[]>       BYTEA                    = new PostgresDataType<byte[]>(SQLDataType.BLOB, "bytea");
+    public static final PostgresDataType<YearToMonth>  INTERVALYEARTOMONTH      = new PostgresDataType<YearToMonth>(SQLDataType.INTERVALYEARTOMONTH, "interval year to month");
+    public static final PostgresDataType<DayToSecond>  INTERVALDAYTOSECOND      = new PostgresDataType<DayToSecond>(SQLDataType.INTERVALDAYTOSECOND, "interval day to second");
 
     // -------------------------------------------------------------------------
     // Compatibility types for supported SQLDataTypes
     // -------------------------------------------------------------------------
 
-    protected static final PostgresDataType<byte[]>     __BINARY              = new PostgresDataType<byte[]>(SQLDataType.BINARY, "bytea");
-    protected static final PostgresDataType<Boolean>    __BIT                 = new PostgresDataType<Boolean>(SQLDataType.BIT, "boolean");
-    protected static final PostgresDataType<byte[]>     __LONGVARBINARY       = new PostgresDataType<byte[]>(SQLDataType.LONGVARBINARY, "bytea");
-    protected static final PostgresDataType<String>     __LONGVARCHAR         = new PostgresDataType<String>(SQLDataType.LONGVARCHAR, "varchar");
-    protected static final PostgresDataType<String>     __NCHAR               = new PostgresDataType<String>(SQLDataType.NCHAR, "char");
-    protected static final PostgresDataType<String>     __NCLOB               = new PostgresDataType<String>(SQLDataType.NCLOB, "text");
-    protected static final PostgresDataType<String>     __LONGNVARCHAR        = new PostgresDataType<String>(SQLDataType.LONGNVARCHAR, "varchar");
-    protected static final PostgresDataType<String>     __NVARCHAR            = new PostgresDataType<String>(SQLDataType.NVARCHAR, "varchar");
-    protected static final PostgresDataType<Byte>       __TINYINT             = new PostgresDataType<Byte>(SQLDataType.TINYINT, "smallint");
-    protected static final PostgresDataType<byte[]>     __VARBINARY           = new PostgresDataType<byte[]>(SQLDataType.VARBINARY, "bytea");
+    protected static final PostgresDataType<byte[]>     __BINARY                = new PostgresDataType<byte[]>(SQLDataType.BINARY, "bytea");
+    protected static final PostgresDataType<Boolean>    __BIT                   = new PostgresDataType<Boolean>(SQLDataType.BIT, "boolean");
+    protected static final PostgresDataType<byte[]>     __LONGVARBINARY         = new PostgresDataType<byte[]>(SQLDataType.LONGVARBINARY, "bytea");
+    protected static final PostgresDataType<String>     __LONGVARCHAR           = new PostgresDataType<String>(SQLDataType.LONGVARCHAR, "varchar");
+    protected static final PostgresDataType<String>     __NCHAR                 = new PostgresDataType<String>(SQLDataType.NCHAR, "char");
+    protected static final PostgresDataType<String>     __NCLOB                 = new PostgresDataType<String>(SQLDataType.NCLOB, "text");
+    protected static final PostgresDataType<String>     __LONGNVARCHAR          = new PostgresDataType<String>(SQLDataType.LONGNVARCHAR, "varchar");
+    protected static final PostgresDataType<String>     __NVARCHAR              = new PostgresDataType<String>(SQLDataType.NVARCHAR, "varchar");
+    protected static final PostgresDataType<Byte>       __TINYINT               = new PostgresDataType<Byte>(SQLDataType.TINYINT, "smallint");
+    protected static final PostgresDataType<byte[]>     __VARBINARY             = new PostgresDataType<byte[]>(SQLDataType.VARBINARY, "bytea");
 
     // -------------------------------------------------------------------------
     // Compatibility types for supported Java types
     // -------------------------------------------------------------------------
 
-    protected static final PostgresDataType<BigInteger> __BIGINTEGER          = new PostgresDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal");
+    protected static final PostgresDataType<BigInteger> __BIGINTEGER            = new PostgresDataType<BigInteger>(SQLDataType.DECIMAL_INTEGER, "decimal");
 
     // -------------------------------------------------------------------------
     // Dialect-specific data types and synonyms thereof
     // -------------------------------------------------------------------------
 
-    public static final PostgresDataType<Integer>    SERIAL                   = new PostgresDataType<Integer>(SQLDataType.INTEGER, "serial");
-    public static final PostgresDataType<Integer>    SERIAL4                  = new PostgresDataType<Integer>(SQLDataType.INTEGER, "serial4");
-    public static final PostgresDataType<Long>       BIGSERIAL                = new PostgresDataType<Long>(SQLDataType.BIGINT, "bigserial");
-    public static final PostgresDataType<Long>       SERIAL8                  = new PostgresDataType<Long>(SQLDataType.BIGINT, "serial8");
-    public static final PostgresDataType<BigDecimal> MONEY                    = new PostgresDataType<BigDecimal>(SQLDataType.DECIMAL, "money");
-    public static final PostgresDataType<String>     BITVARYING               = new PostgresDataType<String>(SQLDataType.VARCHAR, "bit varying");
-    public static final PostgresDataType<String>     VARBIT                   = new PostgresDataType<String>(SQLDataType.VARCHAR, "varbit");
-    public static final PostgresDataType<String>     BIT                      = new PostgresDataType<String>(SQLDataType.CHAR, "bit");
-    public static final PostgresDataType<String>     BPCHAR                   = new PostgresDataType<String>(SQLDataType.CHAR, "bpchar");
-    public static final PostgresDataType<Time>       TIMEWITHOUTTIMEZONE      = new PostgresDataType<Time>(SQLDataType.TIME, "time without time zone");
-    public static final PostgresDataType<Time>       TIMEWITHTIMEZONE         = new PostgresDataType<Time>(SQLDataType.TIME, "time with time zone");
-    public static final PostgresDataType<Time>       TIMETZ                   = new PostgresDataType<Time>(SQLDataType.TIME, "timetz");
-    public static final PostgresDataType<Timestamp>  TIMESTAMPWITHOUTTIMEZONE = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp without time zone");
-    public static final PostgresDataType<Timestamp>  TIMESTAMPWITHTIMEZONE    = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp with time zone");
-    public static final PostgresDataType<Timestamp>  TIMESTAMPTZ              = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamptz");
-    public static final PostgresDataType<Result<Record>> REFCURSOR            = new PostgresDataType<Result<Record>>(SQLDataType.RESULT, "refcursor");
+    public static final PostgresDataType<Integer>    SERIAL                     = new PostgresDataType<Integer>(SQLDataType.INTEGER, "serial");
+    public static final PostgresDataType<Integer>    SERIAL4                    = new PostgresDataType<Integer>(SQLDataType.INTEGER, "serial4");
+    public static final PostgresDataType<Long>       BIGSERIAL                  = new PostgresDataType<Long>(SQLDataType.BIGINT, "bigserial");
+    public static final PostgresDataType<Long>       SERIAL8                    = new PostgresDataType<Long>(SQLDataType.BIGINT, "serial8");
+    public static final PostgresDataType<BigDecimal> MONEY                      = new PostgresDataType<BigDecimal>(SQLDataType.DECIMAL, "money");
+    public static final PostgresDataType<String>     BITVARYING                 = new PostgresDataType<String>(SQLDataType.VARCHAR, "bit varying");
+    public static final PostgresDataType<String>     VARBIT                     = new PostgresDataType<String>(SQLDataType.VARCHAR, "varbit");
+    public static final PostgresDataType<String>     BIT                        = new PostgresDataType<String>(SQLDataType.CHAR, "bit");
+    public static final PostgresDataType<String>     BPCHAR                     = new PostgresDataType<String>(SQLDataType.CHAR, "bpchar");
+    public static final PostgresDataType<Time>       TIMEWITHOUTTIMEZONE        = new PostgresDataType<Time>(SQLDataType.TIME, "time without time zone");
+    public static final PostgresDataType<Time>       TIMEWITHTIMEZONE           = new PostgresDataType<Time>(SQLDataType.TIME, "time with time zone");
+    public static final PostgresDataType<Time>       TIMETZ                     = new PostgresDataType<Time>(SQLDataType.TIME, "timetz");
+    public static final PostgresDataType<Timestamp>  TIMESTAMPWITHOUTTIMEZONE   = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp without time zone");
+    public static final PostgresDataType<Timestamp>  TIMESTAMPWITHTIMEZONE      = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamp with time zone");
+    public static final PostgresDataType<Timestamp>  TIMESTAMPTZ                = new PostgresDataType<Timestamp>(SQLDataType.TIMESTAMP, "timestamptz");
+    public static final PostgresDataType<Result<Record>> REFCURSOR              = new PostgresDataType<Result<Record>>(SQLDataType.RESULT, "refcursor");
 
     // Meta-table types
-    public static final PostgresDataType<Long>       OID                      = new PostgresDataType<Long>(SQLDataType.BIGINT, "oid");
-    public static final PostgresDataType<Long>       OIDVECTOR                = new PostgresDataType<Long>(SQLDataType.BIGINT, "oidvector");
-    public static final PostgresDataType<Long>       XID                      = new PostgresDataType<Long>(SQLDataType.BIGINT, "xid");
-    public static final PostgresDataType<Long>       TID                      = new PostgresDataType<Long>(SQLDataType.BIGINT, "tid");
-    public static final PostgresDataType<Long>       CID                      = new PostgresDataType<Long>(SQLDataType.BIGINT, "cid");
-    public static final PostgresDataType<String>     ACLITEM                  = new PostgresDataType<String>(SQLDataType.VARCHAR, "aclitem");
-    public static final PostgresDataType<String>     NAME                     = new PostgresDataType<String>(SQLDataType.VARCHAR, "name");
-    public static final PostgresDataType<String>     REGPROC                  = new PostgresDataType<String>(SQLDataType.VARCHAR, "regproc");
+    public static final PostgresDataType<Long>       OID                        = new PostgresDataType<Long>(SQLDataType.BIGINT, "oid");
+    public static final PostgresDataType<Long>       OIDVECTOR                  = new PostgresDataType<Long>(SQLDataType.BIGINT, "oidvector");
+    public static final PostgresDataType<Long>       XID                        = new PostgresDataType<Long>(SQLDataType.BIGINT, "xid");
+    public static final PostgresDataType<Long>       TID                        = new PostgresDataType<Long>(SQLDataType.BIGINT, "tid");
+    public static final PostgresDataType<Long>       CID                        = new PostgresDataType<Long>(SQLDataType.BIGINT, "cid");
+    public static final PostgresDataType<String>     ACLITEM                    = new PostgresDataType<String>(SQLDataType.VARCHAR, "aclitem");
+    public static final PostgresDataType<String>     NAME                       = new PostgresDataType<String>(SQLDataType.VARCHAR, "name");
+    public static final PostgresDataType<String>     REGPROC                    = new PostgresDataType<String>(SQLDataType.VARCHAR, "regproc");
 
 
     private PostgresDataType(SQLDataType<T> sqlDataType, String typeName) {