activerecord 5.0.0 → 5.0.7.2

data/lib/active_record/model_schema.rb

@@ -1,78 +1,145 @@
+require "monitor"
+
 module ActiveRecord
   module ModelSchema
     extend ActiveSupport::Concern
 
+    ##
+    # :singleton-method: primary_key_prefix_type
+    # :call-seq: primary_key_prefix_type
+    #
+    # The prefix type that will be prepended to every primary key column name.
+    # The options are +:table_name+ and +:table_name_with_underscore+. If the first is specified,
+    # the Product class will look for "productid" instead of "id" as the primary column. If the
+    # latter is specified, the Product class will look for "product_id" instead of "id". Remember
+    # that this is a global setting for all Active Records.
+
+    ##
+    # :singleton-method: primary_key_prefix_type=
+    # :call-seq: primary_key_prefix_type=(prefix_type)
+    #
+    # Sets the prefix type that will be prepended to every primary key column name.
+    # The options are +:table_name+ and +:table_name_with_underscore+. If the first is specified,
+    # the Product class will look for "productid" instead of "id" as the primary column. If the
+    # latter is specified, the Product class will look for "product_id" instead of "id". Remember
+    # that this is a global setting for all Active Records.
+
+    ##
+    # :singleton-method: table_name_prefix
+    # :call-seq: table_name_prefix
+    #
+    # The prefix string to prepend to every table name.
+
+    ##
+    # :singleton-method: table_name_prefix=
+    # :call-seq: table_name_prefix=(prefix)
+    #
+    # Sets the prefix string to prepend to every table name. So if set to "basecamp_", all table
+    # names will be named like "basecamp_projects", "basecamp_people", etc. This is a convenient
+    # way of creating a namespace for tables in a shared database. By default, the prefix is the
+    # empty string.
+    #
+    # If you are organising your models within modules you can add a prefix to the models within
+    # a namespace by defining a singleton method in the parent module called table_name_prefix which
+    # returns your chosen prefix.
+
+    ##
+    # :singleton-method: table_name_suffix
+    # :call-seq: table_name_suffix
+    #
+    # The suffix string to append to every table name.
+
+    ##
+    # :singleton-method: table_name_suffix=
+    # :call-seq: table_name_suffix=(suffix)
+    #
+    # Works like +table_name_prefix=+, but appends instead of prepends (set to "_basecamp" gives "projects_basecamp",
+    # "people_basecamp"). By default, the suffix is the empty string.
+    #
+    # If you are organising your models within modules, you can add a suffix to the models within
+    # a namespace by defining a singleton method in the parent module called table_name_suffix which
+    # returns your chosen suffix.
+
+    ##
+    # :singleton-method: schema_migrations_table_name
+    # :call-seq: schema_migrations_table_name
+    #
+    # The name of the schema migrations table. By default, the value is <tt>"schema_migrations"</tt>.
+
+    ##
+    # :singleton-method: schema_migrations_table_name=
+    # :call-seq: schema_migrations_table_name=(table_name)
+    #
+    # Sets the name of the schema migrations table.
+
+    ##
+    # :singleton-method: internal_metadata_table_name
+    # :call-seq: internal_metadata_table_name
+    #
+    # The name of the internal metadata table. By default, the value is <tt>"ar_internal_metadata"</tt>.
+
+    ##
+    # :singleton-method: internal_metadata_table_name=
+    # :call-seq: internal_metadata_table_name=(table_name)
+    #
+    # Sets the name of the internal metadata table.
+
+    ##
+    # :singleton-method: protected_environments
+    # :call-seq: protected_environments
+    #
+    # The array of names of environments where destructive actions should be prohibited. By default,
+    # the value is <tt>["production"]</tt>.
+
+    ##
+    # :singleton-method: protected_environments=
+    # :call-seq: protected_environments=(environments)
+    #
+    # Sets an array of names of environments where destructive actions should be prohibited.
+
+    ##
+    # :singleton-method: pluralize_table_names
+    # :call-seq: pluralize_table_names
+    #
+    # Indicates whether table names should be the pluralized versions of the corresponding class names.
+    # If true, the default table name for a Product class will be "products". If false, it would just be "product".
+    # See table_name for the full rules on table/class naming. This is true, by default.
+
+    ##
+    # :singleton-method: pluralize_table_names=
+    # :call-seq: pluralize_table_names=(value)
+    #
+    # Set whether table names should be the pluralized versions of the corresponding class names.
+    # If true, the default table name for a Product class will be "products". If false, it would just be "product".
+    # See table_name for the full rules on table/class naming. This is true, by default.
+
     included do
-      ##
-      # :singleton-method:
-      # Accessor for the prefix type that will be prepended to every primary key column name.
-      # The options are :table_name and :table_name_with_underscore. If the first is specified,
-      # the Product class will look for "productid" instead of "id" as the primary column. If the
-      # latter is specified, the Product class will look for "product_id" instead of "id". Remember
-      # that this is a global setting for all Active Records.
       mattr_accessor :primary_key_prefix_type, instance_writer: false
 
-      ##
-      # :singleton-method:
-      # Accessor for the name of the prefix string to prepend to every table name. So if set
-      # to "basecamp_", all table names will be named like "basecamp_projects", "basecamp_people",
-      # etc. This is a convenient way of creating a namespace for tables in a shared database.
-      # By default, the prefix is the empty string.
-      #
-      # If you are organising your models within modules you can add a prefix to the models within
-      # a namespace by defining a singleton method in the parent module called table_name_prefix which
-      # returns your chosen prefix.
       class_attribute :table_name_prefix, instance_writer: false
       self.table_name_prefix = ""
 
-      ##
-      # :singleton-method:
-      # Works like +table_name_prefix+, but appends instead of prepends (set to "_basecamp" gives "projects_basecamp",
-      # "people_basecamp"). By default, the suffix is the empty string.
-      #
-      # If you are organising your models within modules, you can add a suffix to the models within
-      # a namespace by defining a singleton method in the parent module called table_name_suffix which
-      # returns your chosen suffix.
       class_attribute :table_name_suffix, instance_writer: false
       self.table_name_suffix = ""
 
-      ##
-      # :singleton-method:
-      # Accessor for the name of the schema migrations table. By default, the value is "schema_migrations"
       class_attribute :schema_migrations_table_name, instance_accessor: false
       self.schema_migrations_table_name = "schema_migrations"
 
-      ##
-      # :singleton-method:
-      # Accessor for the name of the internal metadata table. By default, the value is "ar_internal_metadata"
       class_attribute :internal_metadata_table_name, instance_accessor: false
       self.internal_metadata_table_name = "ar_internal_metadata"
 
-      ##
-      # :singleton-method:
-      # Accessor for an array of names of environments where destructive actions should be prohibited. By default,
-      # the value is ["production"]
       class_attribute :protected_environments, instance_accessor: false
       self.protected_environments = ["production"]
 
-      ##
-      # :singleton-method:
-      # Indicates whether table names should be the pluralized versions of the corresponding class names.
-      # If true, the default table name for a Product class will be +products+. If false, it would just be +product+.
-      # See table_name for the full rules on table/class naming. This is true, by default.
       class_attribute :pluralize_table_names, instance_writer: false
       self.pluralize_table_names = true
 
-      ##
-      # :singleton-method:
-      # Accessor for the list of columns names the model should ignore. Ignored columns won't have attribute
-      # accessors defined, and won't be referenced in SQL queries.
-      class_attribute :ignored_columns, instance_accessor: false
-      self.ignored_columns = [].freeze
-
       self.inheritance_column = 'type'
+      self.ignored_columns = [].freeze
 
       delegate :type_for_attribute, to: :class
+
+      initialize_load_schema_monitor
     end
 
     # Derives the join table name for +first_table+ and +second_table+. The
@@ -199,6 +266,22 @@ module ActiveRecord
         @explicit_inheritance_column = true
       end
 
+      # The list of columns names the model should ignore. Ignored columns won't have attribute
+      # accessors defined, and won't be referenced in SQL queries.
+      def ignored_columns
+        if defined?(@ignored_columns)
+          @ignored_columns
+        else
+          superclass.ignored_columns
+        end
+      end
+
+      # Sets the columns names the model should ignore. Ignored columns won't have attribute
+      # accessors defined, and won't be referenced in SQL queries.
+      def ignored_columns=(columns)
+        @ignored_columns = columns.map(&:to_s)
+      end
+
       def sequence_name
         if base_class == self
           @sequence_name ||= reset_sequence_name
@@ -249,7 +332,11 @@ module ActiveRecord
       end
 
       def attributes_builder # :nodoc:
-        @attributes_builder ||= AttributeSet::Builder.new(attribute_types, primary_key)
+        unless defined?(@attributes_builder) && @attributes_builder
+          defaults = _default_attributes.except(*(column_names - [primary_key]))
+          @attributes_builder = AttributeSet::Builder.new(attribute_types, defaults)
+        end
+        @attributes_builder
       end
 
       def columns_hash # :nodoc:
@@ -278,8 +365,12 @@ module ActiveRecord
       #
       # +attr_name+ The name of the attribute to retrieve the type for. Must be
       # a string
-      def type_for_attribute(attr_name)
-        attribute_types[attr_name]
+      def type_for_attribute(attr_name, &block)
+        if block
+          attribute_types.fetch(attr_name, &block)
+        else
+          attribute_types[attr_name]
+        end
       end
 
       # Returns a hash where the keys are column names and the values are
@@ -336,17 +427,34 @@ module ActiveRecord
         connection.schema_cache.clear_data_source_cache!(table_name)
 
         reload_schema_from_cache
+        initialize_find_by_cache
+      end
+
+      protected
+
+      def initialize_load_schema_monitor
+        @load_schema_monitor = Monitor.new
       end
 
       private
 
+      def inherited(child_class)
+        super
+        child_class.initialize_load_schema_monitor
+      end
+
       def schema_loaded?
-        defined?(@columns_hash) && @columns_hash
+        defined?(@schema_loaded) && @schema_loaded
       end
 
       def load_schema
-        unless schema_loaded?
+        return if schema_loaded?
+        @load_schema_monitor.synchronize do
+          return if defined?(@columns_hash) && @columns_hash
+
           load_schema!
+
+          @schema_loaded = true
         end
       end
 
@@ -374,6 +482,7 @@ module ActiveRecord
         @attributes_builder = nil
         @columns = nil
         @columns_hash = nil
+        @schema_loaded = false
         @attribute_names = nil
         direct_descendants.each do |descendant|
           descendant.send(:reload_schema_from_cache)

data/lib/active_record/no_touching.rb

@@ -45,6 +45,10 @@ module ActiveRecord
       NoTouching.applied_to?(self.class)
     end
 
+    def touch_later(*) # :nodoc:
+      super unless no_touching?
+    end
+
     def touch(*) # :nodoc:
       super unless no_touching?
     end

data/lib/active_record/persistence.rb

@@ -63,10 +63,10 @@ module ActiveRecord
       #
       # See <tt>ActiveRecord::Inheritance#discriminate_class_for_record</tt> to see
       # how this "single-table" inheritance mapping is implemented.
-      def instantiate(attributes, column_types = {})
+      def instantiate(attributes, column_types = {}, &block)
         klass = discriminate_class_for_record(attributes)
         attributes = klass.attributes_builder.build_from_database(attributes, column_types)
-        klass.allocate.init_with('attributes' => attributes, 'new_record' => false)
+        klass.allocate.init_with("attributes" => attributes, "new_record" => false, &block)
       end
 
       private
@@ -100,6 +100,10 @@ module ActiveRecord
       !(@new_record || @destroyed)
     end
 
+    ##
+    # :call-seq:
+    #   save(*args)
+    #
     # Saves the model.
     #
     # If the model is new, a record gets created in the database, otherwise
@@ -121,12 +125,16 @@ module ActiveRecord
     #
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
-    def save(*args)
-      create_or_update(*args)
+    def save(*args, &block)
+      create_or_update(*args, &block)
     rescue ActiveRecord::RecordInvalid
       false
     end
 
+    ##
+    # :call-seq:
+    #   save!(*args)
+    #
     # Saves the model.
     #
     # If the model is new, a record gets created in the database, otherwise
@@ -148,8 +156,8 @@ module ActiveRecord
     #
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
-    def save!(*args)
-      create_or_update(*args) || raise(RecordNotSaved.new("Failed to save the record", self))
+    def save!(*args, &block)
+      create_or_update(*args, &block) || raise(RecordNotSaved.new("Failed to save the record", self))
     end
 
     # Deletes the record in the database and freezes this instance to
@@ -252,7 +260,8 @@ module ActiveRecord
       name = name.to_s
       verify_readonly_attribute(name)
       public_send("#{name}=", value)
-      save(validate: false) if changed?
+
+      changed? ? save(validate: false) : true
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the
@@ -329,10 +338,10 @@ module ActiveRecord
       self
     end
 
-    # Wrapper around #increment that saves the record. This method differs from
-    # its non-bang version in that it passes through the attribute setter.
-    # Saving is not subjected to validation checks. Returns +true+ if the
-    # record could be saved.
+    # Wrapper around #increment that writes the update to the database.
+    # Only +attribute+ is updated; the record itself is not saved.
+    # This means that any other modified attributes will still be dirty.
+    # Validations and callbacks are skipped. Returns +self+.
     def increment!(attribute, by = 1)
       increment(attribute, by)
       change = public_send(attribute) - (attribute_was(attribute.to_s) || 0)
@@ -348,10 +357,10 @@ module ActiveRecord
       increment(attribute, -by)
     end
 
-    # Wrapper around #decrement that saves the record. This method differs from
-    # its non-bang version in the sense that it passes through the attribute setter.
-    # Saving is not subjected to validation checks. Returns +true+ if the
-    # record could be saved.
+    # Wrapper around #decrement that writes the update to the database.
+    # Only +attribute+ is updated; the record itself is not saved.
+    # This means that any other modified attributes will still be dirty.
+    # Validations and callbacks are skipped. Returns +self+.
     def decrement!(attribute, by = 1)
       increment!(attribute, -by)
     end
@@ -479,7 +488,12 @@ module ActiveRecord
     #   ball.touch(:updated_at)   # => raises ActiveRecordError
     #
     def touch(*names, time: nil)
-      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
+      unless persisted?
+        raise ActiveRecordError, <<-MSG.squish
+          cannot touch on a new or destroyed record object. Consider using
+          persisted?, new_record?, or destroyed? before touching
+        MSG
+      end
 
       time ||= current_time_from_proper_timezone
       attributes = timestamp_attributes_for_update_in_model
@@ -529,9 +543,9 @@ module ActiveRecord
       self.class.unscoped.where(self.class.primary_key => id)
     end
 
-    def create_or_update(*args)
+    def create_or_update(*args, &block)
       raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
-      result = new_record? ? _create_record : _update_record(*args)
+      result = new_record? ? _create_record(&block) : _update_record(*args, &block)
       result != false
     end
 
@@ -540,10 +554,14 @@ module ActiveRecord
     def _update_record(attribute_names = self.attribute_names)
       attributes_values = arel_attributes_with_values_for_update(attribute_names)
       if attributes_values.empty?
-        0
+        rows_affected = 0
       else
-        self.class.unscoped._update_record attributes_values, id, id_was
+        rows_affected = self.class.unscoped._update_record attributes_values, id, id_was
       end
+
+      yield(self) if block_given?
+
+      rows_affected
     end
 
     # Creates a record with values matching those of the instance attributes
@@ -555,6 +573,9 @@ module ActiveRecord
       self.id ||= new_id if self.class.primary_key
 
       @new_record = false
+
+      yield(self) if block_given?
+
       id
     end
 

data/lib/active_record/query_cache.rb

@@ -5,7 +5,7 @@ module ActiveRecord
       # Enable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
       def cache(&block)
-        if connected?
+        if connected? || !configurations.empty?
           connection.cache(&block)
         else
           yield
@@ -15,7 +15,7 @@ module ActiveRecord
       # Disable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
       def uncached(&block)
-        if connected?
+        if connected? || !configurations.empty?
           connection.uncached(&block)
         else
           yield
@@ -24,30 +24,28 @@ module ActiveRecord
     end
 
     def self.run
-      connection    = ActiveRecord::Base.connection
-      enabled       = connection.query_cache_enabled
       connection_id = ActiveRecord::Base.connection_id
-      connection.enable_query_cache!
 
-      [enabled, connection_id]
-    end
+      caching_pool = ActiveRecord::Base.connection_pool
+      caching_was_enabled = caching_pool.query_cache_enabled
+
+      caching_pool.enable_query_cache!
 
-    def self.complete(state)
-      enabled, connection_id = state
+      [caching_pool, caching_was_enabled, connection_id]
+    end
 
+    def self.complete((caching_pool, caching_was_enabled, connection_id))
       ActiveRecord::Base.connection_id = connection_id
-      ActiveRecord::Base.connection.clear_query_cache
-      ActiveRecord::Base.connection.disable_query_cache! unless enabled
+
+      caching_pool.disable_query_cache! unless caching_was_enabled
+
+      ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
+        pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
+      end
     end
 
     def self.install_executor_hooks(executor = ActiveSupport::Executor)
       executor.register_hook(self)
-
-      executor.to_complete do
-        unless ActiveRecord::Base.connection.transaction_open?
-          ActiveRecord::Base.clear_active_connections!
-        end
-      end
     end
   end
 end

data/lib/active_record/querying.rb

@@ -35,7 +35,7 @@ module ActiveRecord
     #
     #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
     #   Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
-    def find_by_sql(sql, binds = [], preparable: nil)
+    def find_by_sql(sql, binds = [], preparable: nil, &block)
       result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable)
       column_types = result_set.column_types.dup
       columns_hash.each_key { |k| column_types.delete k }
@@ -46,8 +46,8 @@ module ActiveRecord
         class_name: name
       }
 
-      message_bus.instrument('instantiation.active_record', payload) do
-        result_set.map { |record| instantiate(record, column_types) }
+      message_bus.instrument("instantiation.active_record", payload) do
+        result_set.map { |record| instantiate(record, column_types, &block) }
       end
     end
 

data/lib/active_record/railties/controller_runtime.rb

@@ -19,7 +19,7 @@ module ActiveRecord
       end
 
       def cleanup_view_runtime
-        if logger.info? && ActiveRecord::Base.connected?
+        if logger && logger.info? && ActiveRecord::Base.connected?
           db_rt_before_render = ActiveRecord::LogSubscriber.reset_runtime
           self.db_runtime = (db_runtime || 0) + db_rt_before_render
           runtime = super

data/lib/active_record/railties/databases.rake

@@ -77,6 +77,8 @@ db_namespace = namespace :db do
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
     task :redo => [:environment, :load_config] do
+      raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
       if ENV['VERSION']
         db_namespace['migrate:down'].invoke
         db_namespace['migrate:up'].invoke
@@ -91,16 +93,17 @@ db_namespace = namespace :db do
 
     # desc 'Runs the "up" for a given migration VERSION.'
     task :up => [:environment, :load_config] do
+      raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
       ActiveRecord::Migrator.run(:up, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
+      raise "VERSION is required - To go down one migration, use db:rollback" if !ENV["VERSION"] || ENV["VERSION"].empty?
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required - To go down one migration, run db:rollback' unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
@@ -110,28 +113,13 @@ db_namespace = namespace :db do
       unless ActiveRecord::SchemaMigration.table_exists?
         abort 'Schema migrations table does not exist yet.'
       end
-      db_list = ActiveRecord::SchemaMigration.normalized_versions
-
-      file_list =
-          ActiveRecord::Tasks::DatabaseTasks.migrations_paths.flat_map do |path|
-            Dir.foreach(path).map do |file|
-              next unless ActiveRecord::Migrator.match_to_migration_filename?(file)
-
-              version, name, scope = ActiveRecord::Migrator.parse_migration_filename(file)
-              version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
-              status = db_list.delete(version) ? 'up' : 'down'
-              [status, version, (name + scope).humanize]
-            end.compact
-          end
 
-      db_list.map! do |version|
-        ['up', version, '********** NO FILE **********']
-      end
       # output
       puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
       puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
       puts "-" * 50
-      (db_list + file_list).sort_by { |_, version, _| version }.each do |status, version, name|
+      paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+      ActiveRecord::Migrator.migrations_status(paths).each do |status, version, name|
         puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts
@@ -335,7 +323,7 @@ db_namespace = namespace :db do
       begin
         should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
         ActiveRecord::Schema.verbose = false
-        ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations['test'], :ruby, ENV['SCHEMA']
+        ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :ruby, ENV["SCHEMA"], "test"
       ensure
         if should_reconnect
           ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env])
@@ -345,7 +333,7 @@ db_namespace = namespace :db do
 
     # desc "Recreate the test database from an existent structure.sql file"
     task :load_structure => %w(db:test:purge) do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations['test'], :sql, ENV['SCHEMA']
+      ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :sql, ENV["SCHEMA"], "test"
     end
 
     # desc "Recreate the test database from a fresh schema"

data/lib/active_record/reflection.rb

@@ -311,6 +311,10 @@ module ActiveRecord
           active_record == other_aggregation.active_record
       end
 
+      def scope_for(klass)
+        scope ? klass.unscoped.instance_exec(nil, &scope) : klass.unscoped
+      end
+
       private
         def derive_class_name
           name.to_s.camelize
@@ -394,6 +398,10 @@ module ActiveRecord
         options[:primary_key] || primary_key(klass || self.klass)
       end
 
+      def association_primary_key_type
+        klass.type_for_attribute(association_primary_key.to_s)
+      end
+
       def active_record_primary_key
         @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
       end
@@ -519,6 +527,10 @@ module ActiveRecord
         seed + [self]
       end
 
+      def extensions
+        Array(options[:extend])
+      end
+
       protected
 
         def actual_source_reflection # FIXME: this is a horrible name
@@ -632,6 +644,10 @@ module ActiveRecord
           Associations::HasManyAssociation
         end
       end
+
+      def association_primary_key(klass = nil)
+        primary_key(klass || self.klass)
+      end
     end
 
     class HasOneReflection < AssociationReflection # :nodoc:
@@ -847,6 +863,10 @@ module ActiveRecord
         actual_source_reflection.options[:primary_key] || primary_key(klass || self.klass)
       end
 
+      def association_primary_key_type
+        klass.type_for_attribute(association_primary_key.to_s)
+      end
+
       # Gets an array of possible <tt>:through</tt> source reflection names in both singular and plural form.
       #
       #   class Post < ActiveRecord::Base