activerecord 8.1.3.1 → 8.1.4

data/lib/active_record/connection_adapters/mysql/schema_statements.rb

@@ -188,21 +188,7 @@ module ActiveRecord
             MySQL::TableDefinition.new(self, name, **options)
           end
 
-          def default_type(table_name, field_name)
-            match = create_table_info(table_name)&.match(/`#{field_name}` (.+) DEFAULT ('|\d+|[A-z]+)/)
-            default_pre = match[2] if match
-
-            if default_pre == "'"
-              :string
-            elsif default_pre&.match?(/^\d+$/)
-              :integer
-            elsif default_pre&.match?(/^[A-z]+$/)
-              :function
-            end
-          end
-
           def new_column_from_field(table_name, field, _definitions)
-            field_name = field.fetch("Field")
             type_metadata = fetch_type_metadata(field["Type"], field["Extra"])
             default, default_function = field["Default"], nil
 
@@ -210,16 +196,16 @@ module ActiveRecord
               default = "#{default} ON UPDATE #{default}" if /on update CURRENT_TIMESTAMP/i.match?(field["Extra"])
               default, default_function = nil, default
             elsif type_metadata.extra == "DEFAULT_GENERATED"
-              default = +"(#{default})" unless default.start_with?("(")
-              default = default.gsub("\\'", "'")
-              default, default_function = nil, default
+              if mariadb?
+                default, default_function = nil, default
+              else
+                default = "(#{default})" unless default.start_with?("(")
+                default = default.gsub("\\'", "'")
+                default, default_function = nil, default
+              end
             elsif type_metadata.type == :text && default&.start_with?("'")
               # strip and unescape quotes
               default = default[1...-1].gsub("\\'", "'")
-            elsif default&.match?(/\A\d/)
-              # Its a number so we can skip the query to check if it is a function
-            elsif default && default_type(table_name, field_name) == :function
-              default, default_function = nil, default
             end
 
             MySQL::Column.new(

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -27,21 +27,6 @@ module ActiveRecord
           !READ_QUERY.match?(sql.b)
         end
 
-        # Executes an SQL statement, returning a PG::Result object on success
-        # or raising a PG::Error exception otherwise.
-        #
-        # Setting +allow_retry+ to true causes the db to reconnect and retry
-        # executing the SQL statement in case of a connection-related exception.
-        # This option should only be enabled for known idempotent queries.
-        #
-        # Note: the PG::Result object is manually memory managed; if you don't
-        # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
-        def execute(...) # :nodoc:
-          super
-        ensure
-          @notice_receiver_sql_warnings = []
-        end
-
         def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
           if use_insert_returning? || pk == false
             super
@@ -223,7 +208,9 @@ module ActiveRecord
           end
 
           def handle_warnings(result, sql)
-            @notice_receiver_sql_warnings.each do |warning|
+            warnings, @notice_receiver_sql_warnings = @notice_receiver_sql_warnings, []
+
+            warnings.each do |warning|
               next if warning_ignored?(warning)
 
               warning.sql = sql

data/lib/active_record/connection_adapters/postgresql/oid/range.rb

@@ -14,7 +14,10 @@ module ActiveRecord
           end
 
           def type_cast_for_schema(value)
-            value.inspect.gsub("Infinity", "::Float::INFINITY")
+            from = bound_for_schema(value.begin)
+            to   = bound_for_schema(value.end)
+            op   = value.exclude_end? ? "..." : ".."
+            "#{from}#{op}#{to}"
           end
 
           def cast_value(value)
@@ -58,6 +61,19 @@ module ActiveRecord
           end
 
           private
+            def bound_for_schema(bound)
+              case bound
+              when nil
+                "nil"
+              when ::Float::INFINITY
+                "::Float::INFINITY"
+              when -::Float::INFINITY
+                "-::Float::INFINITY"
+              else
+                @subtype.type_cast_for_schema(bound)
+              end
+            end
+
             def type_cast_single(value)
               infinity?(value) ? value : @subtype.deserialize(value)
             end
@@ -67,7 +83,7 @@ module ActiveRecord
             end
 
             def extract_bounds(value)
-              from, to = value[1..-2].split(",", 2)
+              from, to = split_bounds(value[1..-2])
               {
                 from:          (from == "" || from == "-infinity") ? infinity(negative: true) : unquote(from),
                 to:            (to == "" || to == "infinity") ? infinity : unquote(to),
@@ -76,6 +92,33 @@ module ActiveRecord
               }
             end
 
+            # Matches the comma-separated lower and upper bounds of a range's
+            # textual representation when a bound is double-quoted. A quoted
+            # bound can itself contain a comma, so a naive split on the first
+            # comma would corrupt such values. Within a double-quoted bound,
+            # literal " and \ are escaped (as "" / \" and \\ respectively), so
+            # those escapes are skipped while scanning for the separating comma.
+            #
+            # An unquoted bound never contains a comma or a double-quote
+            # (PostgreSQL quotes the whole bound when it would), so the
+            # alternation matches an unquoted run with [^,"] rather than [^,].
+            # Excluding " keeps the two alternatives mutually exclusive, which
+            # removes any ambiguity over how a "-prefixed bound is consumed. The
+            # /m flag lets the captured upper bound (and quoted bounds) span
+            # newlines.
+            BOUNDS = /\A((?:"(?:[^"\\]|""|\\.)*"|[^,"])*),(.*)\z/m # :nodoc:
+
+            def split_bounds(value)
+              # Fast path: an unquoted representation (every built-in range
+              # type -- int/num/date/timestamp) has no embedded comma, so a
+              # plain split is correct and avoids the regexp. Only quoted
+              # bounds (custom text/varchar/money/... ranges) need the
+              # comma-skipping scan.
+              return value.split(",", 2) unless value.include?('"')
+
+              (match = BOUNDS.match(value)) ? [match[1], match[2]] : [value, nil]
+            end
+
             INFINITE_FLOAT_RANGE = (-::Float::INFINITY)..(::Float::INFINITY) # :nodoc:
 
             def sanitize_bounds(from, to)
@@ -94,7 +137,7 @@ module ActiveRecord
             # * https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO
             # * https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-IO-SYNTAX
             def unquote(value)
-              if value.start_with?('"') && value.end_with?('"')
+              if value && value.start_with?('"') && value.end_with?('"')
                 unquoted_value = value[1..-2]
                 unquoted_value.gsub!('""', '"')
                 unquoted_value.gsub!("\\\\", "\\")

data/lib/active_record/connection_adapters/postgresql/referential_integrity.rb

@@ -45,7 +45,7 @@ Rails needs superuser privileges to disable referential integrity.
             BEGIN
             FOR r IN (
               SELECT FORMAT(
-                'UPDATE pg_catalog.pg_constraint SET convalidated=false WHERE conname = ''%1$I'' AND connamespace::regnamespace = ''%2$I''::regnamespace; ALTER TABLE %2$I.%3$I VALIDATE CONSTRAINT %1$I;',
+                'UPDATE pg_catalog.pg_constraint SET convalidated=false WHERE conname = ''%1$I'' AND connamespace::regnamespace = ''%2$I''::regnamespace AND conrelid::regclass = ''%3$I''::regclass; ALTER TABLE %2$I.%3$I VALIDATE CONSTRAINT %1$I;',
                 constraint_name,
                 table_schema,
                 table_name

data/lib/active_record/connection_adapters/postgresql/schema_dumper.rb

@@ -108,7 +108,7 @@ module ActiveRecord
               spec = { type: schema_type(column).inspect }.merge!(spec)
             end
 
-            spec[:enum_type] = column.sql_type.inspect if column.enum?
+            spec[:enum_type] = relation_name(column.sql_type).inspect if column.enum?
 
             spec
           end

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -133,8 +133,9 @@ module ActiveRecord
 
               # add info on sort order (only desc order is explicitly specified, asc is the default)
               # and non-default opclasses
-              expressions.scan(/(?<column>\w+)"?\s?(?<opclass>\w+_ops(_\w+)?)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/).each do |column, opclass, desc, nulls|
-                opclasses[column] = opclass.to_sym if opclass
+              expressions.scan(/(?<column>\w+)"?\s?(?<opclass>(?:\w+\.)?\w+_ops(_\w+)?)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/).each do |column, opclass, desc, nulls|
+                opclasses[column] = opclass.split(".").last.to_sym if opclass
+
                 if nulls
                   orders[column] = [desc, nulls].compact.join(" ")
                 else
@@ -222,6 +223,7 @@ module ActiveRecord
             WHERE child.relname = #{scope[:name]}
               AND child.relkind IN (#{scope[:type]})
               AND n.nspname = #{scope[:schema]}
+            ORDER BY i.inhseqno
           SQL
         end
 
@@ -551,7 +553,12 @@ module ActiveRecord
           result = execute schema_creation.accept(create_index)
 
           index = create_index.index
-          execute "COMMENT ON INDEX #{quote_column_name(index.name)} IS #{quote(index.comment)}" if index.comment
+          if index.comment
+            name = Utils.extract_schema_qualified_name(table_name.to_s)
+            index_name = name.schema ? PostgreSQL::Name.new(name.schema, index.name).to_s : index.name
+            execute "COMMENT ON INDEX #{quote_table_name(index_name)} IS #{quote(index.comment)}"
+          end
+
           result
         end
 
@@ -634,7 +641,7 @@ module ActiveRecord
           SQL
 
           fk_info.map do |row|
-            to_table = Utils.unquote_identifier(row["to_table"])
+            to_table = Utils.extract_schema_qualified_name(row["to_table"]).to_s
 
             column = decode_string_array(row["conkey_names"])
             primary_key = decode_string_array(row["confkey_names"])
@@ -704,7 +711,7 @@ module ActiveRecord
 
           exclusion_info.map do |row|
             method_and_elements, predicate = row["constraintdef"].split(" WHERE ")
-            method_and_elements_parts = method_and_elements.match(/EXCLUDE(?: USING (?<using>\S+))? \((?<expression>.+)\)/)
+            method_and_elements_parts = method_and_elements.match(/EXCLUDE(?: USING (?<using>\S+))? \((?<expression>.+)\)/m)
             predicate.remove!(/ DEFERRABLE(?: INITIALLY (?:IMMEDIATE|DEFERRED))?/) if predicate
             predicate = predicate.from(2).to(-3) if predicate # strip 2 opening and closing parentheses
 
@@ -1113,6 +1120,11 @@ module ActiveRecord
             super
           end
 
+          def validate_table_length!(table_name)
+            _schema, table_name = extract_schema_qualified_name(table_name)
+            super
+          end
+
           def exclusion_constraint_name(table_name, **options)
             options.fetch(:name) do
               expression = options.fetch(:expression)

data/lib/active_record/connection_adapters/schema_cache.rb

@@ -271,10 +271,10 @@ module ActiveRecord
       end
 
       def encode_with(coder) # :nodoc:
-        coder["columns"]          = @columns.sort.to_h.transform_values { _1.sort_by(&:name) }
+        coder["columns"]          = @columns.sort.to_h
         coder["primary_keys"]     = @primary_keys.sort.to_h
         coder["data_sources"]     = @data_sources.sort.to_h
-        coder["indexes"]          = @indexes.sort.to_h.transform_values { _1.sort_by(&:name) }
+        coder["indexes"]          = @indexes.sort.to_h
         coder["version"]          = @version
       end
 

data/lib/active_record/connection_adapters/sqlite3/schema_statements.rb

@@ -21,7 +21,7 @@ module ActiveRecord
               WHERE name = #{quote(row['name'])} AND type = 'index'
             SQL
 
-            /\bON\b\s*"?(\w+?)"?\s*\((?<expressions>.+?)\)(?:\s*WHERE\b\s*(?<where>.+))?(?:\s*\/\*.*\*\/)?\z/i =~ index_sql
+            /\bON\b\s*"?(\w+?)"?\s*\((?<expressions>.+?)\)(?:\s*WHERE\b\s*(?<where>.+?))?(?:\s*\/\*.*\*\/)?\s*\z/im =~ index_sql
 
             columns = internal_exec_query("PRAGMA index_info(#{quote(row['name'])})", "SCHEMA").map do |col|
               col["name"]
@@ -101,7 +101,7 @@ module ActiveRecord
         end
 
         def remove_check_constraint(table_name, expression = nil, if_exists: false, **options)
-          return if if_exists && !check_constraint_exists?(table_name, **options)
+          return if if_exists && !check_constraint_exists?(table_name, expression: expression, **options)
 
           check_constraints = check_constraints(table_name)
           chk_name_to_delete = check_constraint_for!(table_name, expression: expression, **options).name

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -551,6 +551,10 @@ module ActiveRecord
           case default
           when /^null$/i
             nil
+          when /^false$/i
+            false
+          when /^true$/i
+            true
           # Quoted types
           when /^'([^|]*)'$/m
             $1.gsub("''", "'")
@@ -563,8 +567,6 @@ module ActiveRecord
           # Binary columns
           when /x'(.*)'/
             [ $1 ].pack("H*")
-          when "TRUE", "FALSE"
-            default
           else
             # Anything else is blank or some function
             # and we can't know the value of that, so return nil.

data/lib/active_record/connection_adapters/trilogy/database_statements.rb

@@ -10,6 +10,10 @@ module ActiveRecord
         end
 
         private
+          def multi_statements_enabled?
+            @config[:multi_statement]
+          end
+
           def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch: false)
             reset_multi_statement = if batch && !@config[:multi_statement]
               raw_connection.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_ON)

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -18,6 +18,20 @@ module ActiveRecord
 
       include Trilogy::DatabaseStatements
 
+      # Trilogy spells its SSL options with underscores, and supports certificate
+      # revocation lists, which mysql2 does not.
+      self.cli_arg_map = cli_arg_map
+        .except(:sslca, :sslcert, :sslcapath, :sslcipher, :sslkey)
+        .merge(
+          ssl_ca: "--ssl-ca",
+          ssl_cert: "--ssl-cert",
+          ssl_capath: "--ssl-capath",
+          ssl_cipher: "--ssl-cipher",
+          ssl_key: "--ssl-key",
+          ssl_crl: "--ssl-crl",
+          ssl_crlpath: "--ssl-crlpath"
+        ).freeze
+
       SSL_MODES = {
         SSL_MODE_DISABLED: ::Trilogy::SSL_DISABLED,
         SSL_MODE_PREFERRED: ::Trilogy::SSL_PREFERRED_NOVERIFY,

data/lib/active_record/counter_cache.rb

@@ -35,14 +35,16 @@ module ActiveRecord
       #   # attributes.
       #   Post.reset_counters(1, :comments, touch: true)
       def reset_counters(id, *counters, touch: nil)
-        ids = if composite_primary_key?
-          if id.first.is_a?(Array)
-            id
-          else
-            [id]
+        if composite_primary_key?
+          ids = id.first.is_a?(Array) ? id : [id]
+          types = primary_key.map { |column| type_for_attribute(column) }
+          ids = ids.map do |id_value|
+            id_value.map.with_index { |id, i| types[i].cast(id) }
           end
         else
-          Array(id)
+          ids = Array(id)
+          type = type_for_attribute(primary_key)
+          ids = ids.map { |id| type.cast(id) }
         end
 
         updates = Hash.new { |h, k| h[k] = {} }

data/lib/active_record/database_configurations/hash_config.rb

@@ -123,8 +123,15 @@ module ActiveRecord
       end
 
       def keepalive
-        keepalive = (configuration_hash[:keepalive] || 600).to_f
-        keepalive if keepalive > 0
+        case keepalive = configuration_hash[:keepalive]
+        when false
+          nil
+        when nil, true
+          600.0 # default
+        else
+          keepalive = keepalive.to_f
+          keepalive if keepalive > 0.0
+        end
       end
 
       def adapter

data/lib/active_record/database_configurations/url_config.rb

@@ -52,6 +52,8 @@ module ActiveRecord
 
         to_boolean!(@configuration_hash, :replica)
         to_boolean!(@configuration_hash, :database_tasks)
+        to_boolean!(@configuration_hash, :seeds)
+        to_boolean!(@configuration_hash, :use_metadata_table)
 
         @configuration_hash.freeze
       end

data/lib/active_record/disable_joins_association_relation.rb

@@ -27,7 +27,11 @@ module ActiveRecord
       records = @records
 
       records_by_id = records.group_by do |record|
-        record[key]
+        if key.is_a?(Array)
+          key.map { |column| record[column] }
+        else
+          record[key]
+        end
       end
 
       records = ids.flat_map { |id| records_by_id[id] }

data/lib/active_record/encryption/encrypted_fixtures.rb

@@ -15,10 +15,7 @@ module ActiveRecord
           model_class&.encrypted_attributes&.each do |attribute_name|
             if clean_value = fixture[attribute_name.to_s]
               @clean_values[attribute_name.to_s] = clean_value
-
-              type = model_class.type_for_attribute(attribute_name)
-              encrypted_value = type.serialize(clean_value)
-              fixture[attribute_name.to_s] = encrypted_value
+              fixture[attribute_name.to_s] = encrypt(model_class, attribute_name, clean_value)
             end
           end
         end
@@ -27,12 +24,20 @@ module ActiveRecord
           model_class&.encrypted_attributes&.each do |attribute_name|
             if source_attribute_name = model_class.source_attribute_from_preserved_attribute(attribute_name)
               clean_value = @clean_values[source_attribute_name.to_s]
-              type = model_class.type_for_attribute(attribute_name)
-              encrypted_value = type.serialize(clean_value)
-              fixture[attribute_name.to_s] = encrypted_value
+              fixture[attribute_name.to_s] = encrypt(model_class, attribute_name, clean_value)
             end
           end
         end
+
+        def encrypt(model_class, attribute_name, clean_value)
+          encrypted_value = model_class.type_for_attribute(attribute_name).serialize(clean_value)
+
+          if column = model_class.columns_hash[attribute_name.to_s]
+            column.cast_type.deserialize(encrypted_value)
+          else
+            encrypted_value
+          end
+        end
     end
   end
 end

data/lib/active_record/filter_attribute_handler.rb

@@ -64,9 +64,12 @@ module ActiveRecord
         list.each do |attribute|
           next if klass.abstract_class? || klass == Base
 
-          klass_name = klass.name ? klass.model_name.element : nil
-          filter = [klass_name, attribute.to_s].compact.join(".")
-          app.config.filter_parameters << filter unless app.config.filter_parameters.include?(filter)
+          case attribute
+          when Symbol, String
+            klass_name = klass.name ? klass.model_name.element : nil
+            filter = [klass_name, attribute.to_s].compact.join(".")
+            app.config.filter_parameters << filter unless app.config.filter_parameters.include?(filter)
+          end
         end
       end
   end

data/lib/active_record/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 8
     MINOR = 1
-    TINY  = 3
-    PRE   = "1"
+    TINY  = 4
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -32,9 +32,9 @@ module ActiveRecord
   # be triggered. In that case, it'll work just like normal subclasses with no special magic
   # for differentiating between them or reloading the right type with find.
   #
-  # Note, all the attributes for all the cases are kept in the same table.
-  # Read more:
-  # * https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  # All subclasses share the same database table. See the
+  # {Single Table Inheritance pattern}[https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html]
+  # for more background.
   #
   module Inheritance
     extend ActiveSupport::Concern
@@ -237,6 +237,11 @@ module ActiveRecord
       end
 
       protected
+        def reload_schema_from_cache(*) # :nodoc:
+          @finder_needs_type_condition = nil
+          super
+        end
+
         # Returns the class type of the record using the current module as a prefix. So descendants of
         # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)

data/lib/active_record/log_subscriber.rb

@@ -86,23 +86,35 @@ module ActiveRecord
       end
 
       def sql_color(sql)
-        case sql
-        when /\A\s*rollback/mi
-          RED
-        when /select .*for update/mi, /\A\s*lock/mi
-          WHITE
-        when /\A\s*select/i
-          BLUE
-        when /\A\s*insert/i
-          GREEN
-        when /\A\s*update/i
-          YELLOW
-        when /\A\s*delete/i
-          RED
-        when /transaction\s*\Z/i
-          CYAN
+        color = if (match = sql.match(/\A\s*(\w+)(?:\s|\Z)/))
+          case match[1].downcase
+          when "rollback"
+            RED
+          when "lock"
+            WHITE
+          when "select"
+            if sql.match?(/for update/mi)
+              WHITE
+            else
+              BLUE
+            end
+          when "insert"
+            GREEN
+          when "update"
+            YELLOW
+          when "delete"
+            RED
+          end
+        end
+
+        if color
+          color
         else
-          MAGENTA
+          if sql.match?(/transaction\s*\Z/i)
+            CYAN
+          else
+            MAGENTA
+          end
         end
       end
 

data/lib/active_record/message_pack.rb

@@ -23,6 +23,11 @@ module ActiveRecord
       extend self
 
       def install(registry)
+        registry.register_type 118, ActiveRecord::Type::Time::Value,
+          packer: method(:write_time_value),
+          unpacker: method(:read_time_value),
+          recursive: true
+
         registry.register_type 119, ActiveModel::Type::Binary::Data,
           packer: :to_s,
           unpacker: :new
@@ -33,6 +38,14 @@ module ActiveRecord
           recursive: true
       end
 
+      def write_time_value(value, packer)
+        packer.write(value.__getobj__)
+      end
+
+      def read_time_value(unpacker)
+        ActiveRecord::Type::Time::Value.new(unpacker.read)
+      end
+
       def write_record(record, packer)
         packer.write(ActiveRecord::MessagePack.dump(record))
       end

data/lib/active_record/migration/command_recorder.rb

@@ -239,7 +239,9 @@ module ActiveRecord
         end
 
         def invert_remove_column(args)
-          raise ActiveRecord::IrreversibleMigration, "remove_column is only reversible if given a type." if args.size <= 2
+          if args.size <= 2 || args[2].is_a?(Hash)
+            raise ActiveRecord::IrreversibleMigration, "remove_column is only reversible if given a type."
+          end
           super
         end
 
@@ -297,6 +299,13 @@ module ActiveRecord
           [:change_column_null, args]
         end
 
+        def invert_add_column(args)
+          if (options = args.last).is_a?(Hash)
+            options[:if_exists] = options.delete(:if_not_exists) if options.key?(:if_not_exists)
+          end
+          super
+        end
+
         def invert_add_foreign_key(args)
           args.last.delete(:validate) if args.last.is_a?(Hash)
           super
@@ -307,6 +316,7 @@ module ActiveRecord
           from_table, to_table = args
 
           to_table ||= options.delete(:to_table)
+          options[:if_not_exists] = options.delete(:if_exists) if options.key?(:if_exists)
 
           raise ActiveRecord::IrreversibleMigration, "remove_foreign_key is only reversible if given a second table" if to_table.nil?
 
@@ -400,7 +410,7 @@ module ActiveRecord
         end
 
         def invert_drop_virtual_table(args)
-          _enum, values = args.dup.tap(&:extract_options!)
+          _table_name, _module_name, values = args.dup.tap(&:extract_options!)
           raise ActiveRecord::IrreversibleMigration, "drop_virtual_table is only reversible if given options." unless values
           super
         end

data/lib/active_record/model_schema.rb

@@ -435,7 +435,7 @@ module ActiveRecord
 
       def attributes_builder # :nodoc:
         @attributes_builder ||= begin
-          defaults = _default_attributes.except(*(column_names - [primary_key]))
+          defaults = _default_attributes.except(*(column_names - Array(primary_key)))
           ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
         end
       end
@@ -504,7 +504,7 @@ module ActiveRecord
       # and columns used for single table inheritance have been removed.
       def content_columns
         @content_columns ||= columns.reject do |c|
-          c.name == primary_key ||
+          Array(primary_key).include?(c.name) ||
           c.name == inheritance_column ||
           c.name.end_with?("_id", "_count")
         end.freeze