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

Rails 6.1 fixes

Author: enebo

.travis.yml

@@ -37,8 +37,8 @@ before_script:
     mysql -e "grant all privileges on activerecord_unittest.* to rails@localhost;" && \
     mysql -e "grant all privileges on activerecord_unittest2.* to rails@localhost;" && \
     mysql -e "grant all privileges on inexistent_activerecord_unittest.* to rails@localhost;" && \
-    mysql -e "CREATE DATABASE activerecord_unittest DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;" && \
-    mysql -e "CREATE DATABASE activerecord_unittest2 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;" \
+    mysql -e "CREATE DATABASE activerecord_unittest DEFAULT CHARACTER SET utf8mb4;" && \
+    mysql -e "CREATE DATABASE activerecord_unittest2 DEFAULT CHARACTER SET utf8mb4;" \
     || true
   - |
     [ "$DB" == "postgresql" ] && [ "$TEST_PREFIX" == "rails:" ] && \

lib/arel/visitors/postgresql_jdbc.rb

@@ -2,5 +2,5 @@
 
 class Arel::Visitors::PostgreSQL
   # AREL converts bind argument markers "?" to "$n" for PG, but JDBC wants "?".
-  remove_method :visit_Arel_Nodes_BindParam if ArJdbc::AR42
+  remove_method :bind_block
 end

lib/arjdbc/abstract/database_statements.rb

@@ -15,6 +15,7 @@ def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil
         end
 
         materialize_transactions
+        mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
@@ -35,6 +36,7 @@ def exec_query(sql, name = nil, binds = NO_BINDS, prepare: false)
         end
 
         materialize_transactions
+        mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
@@ -55,6 +57,7 @@ def exec_update(sql, name = nil, binds = NO_BINDS)
         end
 
         materialize_transactions
+        mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
@@ -72,6 +75,7 @@ def execute(sql, name = nil)
         end
 
         materialize_transactions
+        mark_transaction_written_if_write(sql)
 
         log(sql, name) { @connection.execute(sql) }
       end

lib/arjdbc/abstract/transaction_support.rb

@@ -79,3 +79,16 @@ def release_savepoint(name = current_savepoint_name)
     end
   end
 end
+
+# patch to avoid the usage of WeakMap
+require 'active_record/connection_adapters/abstract/transaction'
+module ActiveRecord
+  module ConnectionAdapters
+    class Transaction
+      def add_record(record, ensure_finalize = true)
+        @records ||= []
+        @records << record
+      end
+    end
+  end
+end

lib/arjdbc/postgresql/adapter.rb

@@ -48,46 +48,6 @@ def adapter_name
       ADAPTER_NAME
     end
 
-    def get_database_version # :nodoc:
-      begin
-        version = @connection.database_product
-        if match = version.match(/([\d\.]*\d).*?/)
-          version = match[1].split('.').map(&:to_i)
-          # PostgreSQL version representation does not have more than 4 digits
-          # From version 10 onwards, PG has changed its versioning policy to
-          # limit it to only 2 digits. i.e. in 10.x, 10 being the major
-          # version and x representing the patch release
-          # Refer to:
-          #   https://www.postgresql.org/support/versioning/
-          #   https://www.postgresql.org/docs/10/static/libpq-status.html -> PQserverVersion()
-          # for more info
-
-          if version.size >= 3
-            (version[0] * 100 + version[1]) * 100 + version[2]
-          elsif version.size == 2
-            if version[0] >= 10
-              version[0] * 100 * 100 + version[1]
-            else
-              (version[0] * 100 + version[1]) * 100
-            end
-          elsif version.size == 1
-            version[0] * 100 * 100
-          else
-            0
-          end
-        else
-          0
-        end
-      end
-    end
-
-    def check_version # :nodoc:
-      if database_version < 90300
-        raise "Your version of PostgreSQL (#{database_version}) is too old. Active Record supports PostgreSQL >= 9.3."
-      end
-    end
-
-
     def redshift?
       # SELECT version() :
       #  PostgreSQL 8.0.2 on i686-pc-linux-gnu, compiled by GCC gcc (GCC) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3), Redshift 1.0.647
@@ -209,14 +169,14 @@ def supports_index_sort_order?
       true
     end
 
-    def supports_partial_index?
-      true
-    end
-
     def supports_partitioned_indexes?
       database_version >= 110_000
     end
 
+    def supports_partial_index?
+      true
+    end
+
     def supports_expression_index?
       true
     end
@@ -229,6 +189,10 @@ def supports_foreign_keys?
       true
     end
 
+    def supports_check_constraints?
+      true
+    end
+
     def supports_validate_constraints?
       true
     end
@@ -292,7 +256,7 @@ def supports_materialized_views?
       database_version >= 90300
     end
 
-    def supports_foreign_tables? # we don't really support this yet, its a reminder :)
+    def supports_foreign_tables?
       database_version >= 90300
     end
 
@@ -315,11 +279,6 @@ def supports_lazy_transactions?
       true
     end
 
-    # From AR 5.1 postgres_adapter.rb
-    def default_index_type?(index) # :nodoc:
-      index.using == :btree || super
-    end
-
     def get_advisory_lock(lock_id) # :nodoc:
       unless lock_id.is_a?(Integer) && lock_id.bit_length <= 63
         raise(ArgumentError, "PostgreSQL requires advisory lock ids to be a signed 64 bit integer")
@@ -373,6 +332,65 @@ def use_insert_returning?
       @use_insert_returning
     end
 
+    def get_database_version # :nodoc:
+      begin
+        version = @connection.database_product
+        if match = version.match(/([\d\.]*\d).*?/)
+          version = match[1].split('.').map(&:to_i)
+          # PostgreSQL version representation does not have more than 4 digits
+          # From version 10 onwards, PG has changed its versioning policy to
+          # limit it to only 2 digits. i.e. in 10.x, 10 being the major
+          # version and x representing the patch release
+          # Refer to:
+          #   https://www.postgresql.org/support/versioning/
+          #   https://www.postgresql.org/docs/10/static/libpq-status.html -> PQserverVersion()
+          # for more info
+
+          if version.size >= 3
+            (version[0] * 100 + version[1]) * 100 + version[2]
+          elsif version.size == 2
+            if version[0] >= 10
+              version[0] * 100 * 100 + version[1]
+            else
+              (version[0] * 100 + version[1]) * 100
+            end
+          elsif version.size == 1
+            version[0] * 100 * 100
+          else
+            0
+          end
+        else
+          0
+        end
+      end
+    end
+
+    def default_index_type?(index) # :nodoc:
+      index.using == :btree || super
+    end
+
+    def build_insert_sql(insert) # :nodoc:
+      sql = +"INSERT #{insert.into} #{insert.values_list}"
+
+      if insert.skip_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
+      elsif insert.update_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+        sql << insert.touch_model_timestamps_unless { |column| "#{insert.model.quoted_table_name}.#{column} IS NOT DISTINCT FROM excluded.#{column}" }
+        sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+      end
+
+      sql << " RETURNING #{insert.returning}" if insert.returning
+      sql
+    end
+
+    def check_version # :nodoc:
+      if database_version < 90300
+        raise "Your version of PostgreSQL (#{database_version}) is too old. Active Record supports PostgreSQL >= 9.3."
+      end
+    end
+
+
     def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
       val = super
       if !use_insert_returning? && pk
@@ -434,21 +452,6 @@ def last_insert_id_result(sequence_name)
       exec_query("SELECT currval('#{sequence_name}')", 'SQL')
     end
 
-    def build_insert_sql(insert) # :nodoc:
-      sql = +"INSERT #{insert.into} #{insert.values_list}"
-
-      if insert.skip_duplicates?
-        sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
-      elsif insert.update_duplicates?
-        sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
-        sql << insert.touch_model_timestamps_unless { |column| "#{insert.model.quoted_table_name}.#{column} IS NOT DISTINCT FROM excluded.#{column}" }
-        sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
-      end
-
-      sql << " RETURNING #{insert.returning}" if insert.returning
-      sql
-    end
-
     def build_truncate_statements(table_names)
       ["TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"]
     end
@@ -537,6 +540,16 @@ def column_name_for_operation(operation, node)
 
     # Returns the list of a table's column names, data types, and default values.
     #
+    # The underlying query is roughly:
+    #  SELECT column.name, column.type, default.value, column.comment
+    #    FROM column LEFT JOIN default
+    #      ON column.table_id = default.table_id
+    #     AND column.num = default.column_num
+    #   WHERE column.table_id = get_table_id('table_name')
+    #     AND column.num > 0
+    #     AND NOT column.is_dropped
+    #   ORDER BY column.num
+    #
     # If the table name is not prefixed with a schema, the database will
     # take the first match from the schema search path.
     #

lib/arjdbc/postgresql/oid_types.rb

@@ -145,7 +145,7 @@ def initialize_type_map(m = type_map)
         m.register_type 'uuid', OID::Uuid.new
         m.register_type 'xml', OID::Xml.new
         m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
-        m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)
+        m.register_type 'macaddr', OID::Macaddr.new
         m.register_type 'citext', OID::SpecializedString.new(:citext)
         m.register_type 'ltree', OID::SpecializedString.new(:ltree)
         m.register_type 'line', OID::SpecializedString.new(:line)

lib/arjdbc/sqlite3/adapter.rb

@@ -116,6 +116,10 @@ def supports_foreign_keys?
       true
     end
 
+    def supports_check_constraints?
+      true
+    end
+
     def supports_views?
       true
     end
@@ -145,13 +149,6 @@ def supports_index_sort_order?
       true
     end
 
-    # Returns 62. SQLite supports index names up to 64
-    # characters. The rest is used by Rails internally to perform
-    # temporary rename operations
-    def allowed_index_name_length
-      index_name_length - 2
-    end
-
     def native_database_types #:nodoc:
       NATIVE_DATABASE_TYPES
     end
@@ -236,8 +233,11 @@ def primary_keys(table_name) # :nodoc:
       pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
     end
 
-    def remove_index(table_name, column_name, options = {}) #:nodoc:
+      def remove_index(table_name, column_name = nil, **options) # :nodoc:
+        return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
       index_name = index_name_for_remove(table_name, column_name, options)
+
       exec_query "DROP INDEX #{quote_column_name(index_name)}"
     end
 
@@ -288,16 +288,11 @@ def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
       end
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    def change_column(table_name, column_name, type, **options) #:nodoc:
       alter_table(table_name) do |definition|
         definition[column_name].instance_eval do
           self.type    = type
-          self.limit   = options[:limit] if options.include?(:limit)
-          self.default = options[:default] if options.include?(:default)
-          self.null    = options[:null] if options.include?(:null)
-          self.precision = options[:precision] if options.include?(:precision)
-          self.scale   = options[:scale] if options.include?(:scale)
-          self.collation = options[:collation] if options.include?(:collation)
+            self.options.merge!(options)
         end
       end
     end
@@ -397,7 +392,12 @@ def invalid_alter_table_type?(type, options)
         options[:null] == false && options[:default].nil?
     end
 
-    def alter_table(table_name, foreign_keys = foreign_keys(table_name), **options)
+    def alter_table(
+      table_name,
+      foreign_keys = foreign_keys(table_name),
+      check_constraints = check_constraints(table_name),
+      **options
+    )
       altered_table_name = "a#{table_name}"
 
       caller = lambda do |definition|
@@ -410,6 +410,10 @@ def alter_table(table_name, foreign_keys = foreign_keys(table_name), **options)
           definition.foreign_key(to_table, **fk.options)
         end
 
+        check_constraints.each do |chk|
+          definition.check_constraint(chk.expression, **chk.options)
+        end
+
         yield definition if block_given?
       end
 
@@ -462,7 +466,7 @@ def copy_table_indexes(from, to, rename = {})
         name = index.name
         # indexes sqlite creates for internal use start with `sqlite_` and
         # don't need to be copied
-        next if name.starts_with?("sqlite_")
+        next if name.start_with?("sqlite_")
         if to == "a#{from}"
           name = "t#{name}"
         elsif from == "a#{to}"
@@ -479,10 +483,10 @@ def copy_table_indexes(from, to, rename = {})
 
         unless columns.empty?
           # index name can't be the same
-          opts = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
-          opts[:unique] = true if index.unique
-          opts[:where] = index.where if index.where
-          add_index(to, columns, opts)
+          options = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
+          options[:unique] = true if index.unique
+          options[:where] = index.where if index.where
+          add_index(to, columns, **options)
         end
       end
     end
@@ -547,7 +551,7 @@ def table_structure_with_collation(table_name, basic_structure)
           collation_hash[$1] = $2 if COLLATE_REGEX =~ column_string
         end
 
-        basic_structure.map! do |column|
+        basic_structure.map do |column|
           column_name = column["name"]
 
           if collation_hash.has_key? column_name