Merge pull request #1075 from dr-itz/rails61-dev

Rails 6.1 fixes

Author: enebo

lib/arjdbc/abstract/core.rb

@@ -56,6 +56,7 @@ def translate_exception(exception, message:, sql:, binds:)
         case exception
           when SystemExit, SignalException, NoMemoryError then exception
           when ActiveModel::RangeError, TypeError, RuntimeError then exception
+          when ActiveRecord::ConnectionNotEstablished then exception
           else super
         end
       end

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)

lib/arjdbc/sqlite3/adapter.rb

@@ -373,11 +373,6 @@ def bind_params_length
       999
     end
 
-    def initialize_type_map(m = type_map)
-      super
-      register_class_with_limit m, %r(int)i, SQLite3Integer
-    end
-
     def table_structure(table_name)
       structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
       raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
@@ -573,18 +568,6 @@ def configure_connection
       execute("PRAGMA foreign_keys = ON", "SCHEMA")
     end
 
-    # DIFFERENCE: FQN
-    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
-      private
-      def _limit
-        # INTEGER storage class can be stored 8 bytes value.
-        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
-        limit || 8
-      end
-    end
-
-    # DIFFERENCE: FQN
-    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
   # DIFFERENCE: A registration here is moved down to concrete class so we are not registering part of an adapter.
 end
@@ -743,5 +726,23 @@ def combine_multi_statements(total_sql)
         total_sql
       end
     end
+
+    def initialize_type_map(m = type_map)
+      super
+      register_class_with_limit m, %r(int)i, SQLite3Integer
+    end
+
+    # DIFFERENCE: FQN
+    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
+      private
+      def _limit
+        # INTEGER storage class can be stored 8 bytes value.
+        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+        limit || 8
+      end
+    end
+
+    # DIFFERENCE: FQN
+    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
 end

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/mysql/simple_test.rb

@@ -445,7 +445,7 @@ def test_jdbc_error
   def test_execute_after_disconnect
     connection.disconnect!
 
-    assert_raise(ActiveRecord::StatementInvalid) do
+    assert_raise(ActiveRecord::ConnectionNotEstablished) do
       connection.execute('SELECT 1')
     end
 

test/db/postgresql/rake_test.rb

@@ -51,6 +51,9 @@ def do_teardown
 
   test 'rake db:structure:dump and db:structure:load' do
     omit('pg_dump not available') unless self.class.which('pg_dump')
+
+    initial_format = ActiveRecord::Base.schema_format
+    ActiveRecord::Base.schema_format = :sql
     # Rake::Task["db:create"].invoke
     create_rake_test_database do |connection|
       create_schema_migrations_table(connection)
@@ -60,7 +63,7 @@ def do_teardown
     structure_sql = File.join('db', structure_sql_filename)
     begin
       Dir.mkdir 'db' # db/structure.sql
-      Rake::Task["db:structure:dump"].invoke
+      Rake::Task["db:schema:dump"].invoke
 
       assert File.exists?(structure_sql)
       assert_match(/CREATE TABLE .*?.?users/, File.read(structure_sql))
@@ -73,7 +76,7 @@ def do_teardown
       # environment and load_config tasks don't run to set up the
       # connection because they were already ran when dumping the structure
       with_connection db_config.merge(database: db_name) do |_connection|
-        Rake::Task["db:structure:load"].invoke
+        Rake::Task["db:schema:load"].invoke
       end
 
       with_connection db_config.merge(database: db_name) do |connection|
@@ -82,6 +85,7 @@ def do_teardown
     ensure
       File.delete(structure_sql) if File.exists?(structure_sql)
       Dir.rmdir 'db'
+      ActiveRecord::Base.schema_format = initial_format
     end
   end
 

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/byebug.rb

@@ -0,0 +1,4 @@
+# empty placeholder for byebug:
+# Rails started to include byebug in tests, but that one doesn't support
+# JRuby. Since it's only required and nothing more, providing an empty
+# file on the include path is enough to get things going again.

test/rails/excludes/mysql2/ActiveRecord/ConnectionAdapters/ConnectionHandlerTest.rb

@@ -13,3 +13,4 @@
 exclude :test_establish_connection_using_top_level_key_in_two_level_config, 'tries to load SQLite3 driver'
 exclude :test_symbolized_configurations_assignment, 'tries to load SQLite3 driver'
 exclude :test_establish_connection_with_primary_works_without_deprecation, 'tries to load SQLite3 driver'
+exclude :test_retrieve_connection_shows_primary_deprecation_warning_when_established_on_active_record_base, 'tries to load SQLite3 driver'