feat(postgres): add support for interval type

Author: dr-itz

lib/arjdbc/postgresql/adapter.rb

@@ -87,6 +87,9 @@ def configure_connection
         execute("SET time zone '#{tz}'", 'SCHEMA')
       end unless redshift?
 
+      # Set interval output format to ISO 8601 for ease of parsing by ActiveSupport::Duration.parse
+      execute("SET intervalstyle = iso_8601", "SCHEMA")
+
       # SET statements from :variables config hash
       # http://www.postgresql.org/docs/8.3/static/sql-set.html
       (config[:variables] || {}).map do |k, v|

lib/arjdbc/postgresql/oid_types.rb

@@ -155,9 +155,9 @@ def initialize_type_map(m = type_map)
         m.register_type 'polygon', OID::SpecializedString.new(:polygon)
         m.register_type 'circle', OID::SpecializedString.new(:circle)
 
-        m.register_type 'interval' do |_, _, sql_type|
+        m.register_type 'interval' do |*args, sql_type|
           precision = extract_precision(sql_type)
-          OID::SpecializedString.new(:interval, precision: precision)
+          OID::Interval.new(precision: precision)
         end
 
         register_class_with_precision m, 'time', Type::Time
@@ -244,6 +244,7 @@ def load_additional_types(type_map, oid = nil) # :nodoc:
       ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
       ActiveRecord::Type.register(:hstore, OID::Hstore, adapter: :postgresql)
       ActiveRecord::Type.register(:inet, OID::Inet, adapter: :postgresql)
+      ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
       ActiveRecord::Type.register(:json, Type::Json, adapter: :postgresql)
       ActiveRecord::Type.register(:jsonb, OID::Jsonb, adapter: :postgresql)
       ActiveRecord::Type.register(:money, OID::Money, adapter: :postgresql)

src/java/arjdbc/postgresql/PostgreSQLRubyJdbcConnection.java

@@ -436,7 +436,7 @@ protected void setObjectParameter(final ThreadContext context,
                 break;
 
             case "interval":
-                statement.setObject(index, new PGInterval(value.toString()));
+                statement.setObject(index, stringToPGInterval(value.toString()));
                 break;
 
             case "json":
@@ -493,6 +493,74 @@ protected void setObjectParameter(final ThreadContext context,
         }
     }
 
+    private int lookAhead(String value, int position, String find) {
+        char [] tokens = find.toCharArray();
+        int found = -1;
+
+        for ( int i = 0; i < tokens.length; i++ ) {
+            found = value.indexOf(tokens[i], position);
+            if ( found > 0 ) {
+                return found;
+            }
+        }
+        return found;
+    }
+
+    private Object stringToPGInterval(String value) throws SQLException {
+        if (!value.startsWith("P")) return new PGInterval(value);
+
+        PGInterval interval = new PGInterval();
+
+        /* this is copied from pgjdbc with fixes for Rails */
+        int number = 0;
+        String dateValue;
+        String timeValue = null;
+
+        int hasTime = value.indexOf('T');
+        if ( hasTime > 0 ) {
+          /* skip over the P */
+          dateValue = value.substring(1,hasTime);
+          timeValue = value.substring(hasTime + 1);
+        } else {
+          /* skip over the P */
+          dateValue = value.substring(1);
+        }
+
+        for ( int i = 0; i < dateValue.length(); i++ ) {
+          int lookAhead = lookAhead(dateValue, i, "YMD");
+          if (lookAhead > 0) {
+            char type = dateValue.charAt(lookAhead);
+            number = Integer.parseInt(dateValue.substring(i, lookAhead));
+            if (type == 'Y') {
+              interval.setYears(number);
+            } else if (type == 'M') {
+              interval.setMonths(number);
+            } else if (type == 'D') {
+              interval.setDays(number);
+            }
+            i = lookAhead;
+          }
+        }
+        if ( timeValue != null ) {
+          for (int i = 0; i < timeValue.length(); i++) {
+            int lookAhead = lookAhead(timeValue, i, "HMS");
+            if (lookAhead > 0) {
+              char type = timeValue.charAt(lookAhead);
+              String part = timeValue.substring(i, lookAhead);
+              if (timeValue.charAt(lookAhead) == 'H') {
+                interval.setHours(Integer.parseInt(part));
+              } else if (timeValue.charAt(lookAhead) == 'M') {
+                interval.setMinutes(Integer.parseInt(part));
+              } else if (timeValue.charAt(lookAhead) == 'S') {
+                interval.setSeconds(Double.parseDouble(part));
+              }
+              i = lookAhead;
+            }
+          }
+        }
+        return interval;
+    }
+
     protected IRubyObject jdbcToRuby(ThreadContext context, Ruby runtime, int column, int type, ResultSet resultSet) throws SQLException {
         return typeMap != null ?
                 convertWithTypeMap(context, runtime, column, type, resultSet) :
@@ -874,34 +942,25 @@ private IRubyObject parseInfinity(final Ruby runtime, final String value) {
     private static String formatInterval(final Object object) {
         final PGInterval interval = (PGInterval) object;
         final StringBuilder str = new StringBuilder(32);
+        str.append("P");
 
         final int years = interval.getYears();
-        if (years != 0) str.append(years).append(" years ");
+        if (years != 0) str.append(years).append("Y");
 
         final int months = interval.getMonths();
-        if (months != 0) str.append(months).append(" months ");
+        if (months != 0) str.append(months).append("M");
 
         final int days = interval.getDays();
-        if (days != 0) str.append(days).append(" days ");
+        if (days != 0) str.append(days).append("D");
 
         final int hours = interval.getHours();
         final int mins = interval.getMinutes();
-        final int secs = (int) interval.getSeconds();
-        if (hours != 0 || mins != 0 || secs != 0) { // xx:yy:zz if not all 00
-            if (hours < 10) str.append('0');
-
-            str.append(hours).append(':');
-
-            if (mins < 10) str.append('0');
-
-            str.append(mins).append(':');
-
-            if (secs < 10) str.append('0');
-
-            str.append(secs);
-
-        } else if (str.length() > 1) {
-            str.deleteCharAt(str.length() - 1); // " " at the end
+        final double secs = interval.getSeconds();
+        if (hours != 0 || mins != 0 || secs != 0) {
+            str.append("T");
+            if (hours != 0) str.append(hours).append("H");
+            if (mins != 0) str.append(mins).append("M");
+            if (secs != 0) str.append(secs).append("S");
         }
 
         return str.toString();

test/db/postgresql/types_test.rb

@@ -300,8 +300,8 @@ def test_data_type_of_number_types
   end
 
   def test_data_type_of_time_types
-    assert_instance_of OID::SpecializedString, PostgresqlTime.type_for_attribute('time_interval')
-    assert_instance_of OID::SpecializedString, PostgresqlTime.type_for_attribute('scaled_time_interval')
+    assert_instance_of OID::Interval, PostgresqlTime.type_for_attribute('time_interval')
+    assert_instance_of OID::Interval, PostgresqlTime.type_for_attribute('scaled_time_interval')
   end
 
   def test_data_type_of_network_address_types
@@ -554,8 +554,8 @@ def test_number_values
 
   def test_time_values
     # omit_unless ar_version('4.0')
-    assert_equal '-1 years -2 days', @first_time.time_interval
-    assert_equal '-21 days', @first_time.scaled_time_interval
+    assert_equal '-1 years and -2 days', @first_time.time_interval.inspect
+    assert_equal '-21 days', @first_time.scaled_time_interval.inspect
   end
 
   def test_network_address_values_ipaddr
@@ -644,10 +644,10 @@ def test_update_number
   end
 
   def test_update_time
-    @first_time.time_interval = '2 years 3 minutes'
+    @first_time.time_interval = 'P2YT3M'
     @first_time.save!
     @first_time.reload
-    assert_equal '2 years 00:03:00', @first_time.time_interval
+    assert_equal '2 years and 3 minutes', @first_time.time_interval.inspect
   end
 
   def test_update_network_address

test/rails/excludes/postgresql/PostgresqlIntervalTest.rb

@@ -0,0 +1 @@
+exclude :test_interval_type, 'Cannot auto-cast string to :interval using bind params'