activerecord 4.0.4 → 4.1.16

data/lib/active_record/fixtures.rb

@@ -119,6 +119,23 @@ module ActiveRecord
   # perhaps you should reexamine whether your application is properly testable. Hence, dynamic values
   # in fixtures are to be considered a code smell.
   #
+  # Helper methods defined in a fixture will not be available in other fixtures, to prevent against
+  # unwanted inter-test dependencies. Methods used by multiple fixtures should be defined in a module
+  # that is included in <tt>ActiveRecord::FixtureSet.context_class</tt>.
+  #
+  # - define a helper method in `test_helper.rb`
+  #     module FixtureFileHelpers
+  #       def file_sha(path)
+  #         Digest::SHA2.hexdigest(File.read(Rails.root.join('test/fixtures', path)))
+  #       end
+  #     end
+  #     ActiveRecord::FixtureSet.context_class.send :include, FixtureFileHelpers
+  #
+  # - use the helper method in a fixture
+  #     photo:
+  #       name: kitten.png
+  #       sha: <%= file_sha 'files/kitten.png' %>
+  #
   # = Transactional Fixtures
   #
   # Test cases can use begin+rollback to isolate their changes to the database instead of having to
@@ -379,22 +396,16 @@ module ActiveRecord
 
     @@all_cached_fixtures = Hash.new { |h,k| h[k] = {} }
 
-    def self.find_table_name(fixture_set_name) # :nodoc:
-      ActiveSupport::Deprecation.warn(
-        "ActiveRecord::Fixtures.find_table_name is deprecated and shall be removed from future releases.  Use ActiveRecord::Fixtures.default_fixture_model_name instead.")
-      default_fixture_model_name(fixture_set_name)
-    end
-
-    def self.default_fixture_model_name(fixture_set_name) # :nodoc:
-      ActiveRecord::Base.pluralize_table_names ?
+    def self.default_fixture_model_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
+      config.pluralize_table_names ?
         fixture_set_name.singularize.camelize :
         fixture_set_name.camelize
     end
 
-    def self.default_fixture_table_name(fixture_set_name) # :nodoc:
-       "#{ ActiveRecord::Base.table_name_prefix }"\
+    def self.default_fixture_table_name(fixture_set_name, config = ActiveRecord::Base) # :nodoc:
+       "#{ config.table_name_prefix }"\
        "#{ fixture_set_name.tr('/', '_') }"\
-       "#{ ActiveRecord::Base.table_name_suffix }".to_sym
+       "#{ config.table_name_suffix }".to_sym
     end
 
     def self.reset_cache
@@ -442,9 +453,47 @@ module ActiveRecord
     cattr_accessor :all_loaded_fixtures
     self.all_loaded_fixtures = {}
 
-    def self.create_fixtures(fixtures_directory, fixture_set_names, class_names = {})
+    class ClassCache
+      def initialize(class_names, config)
+        @class_names = class_names.stringify_keys
+        @config      = config
+
+        # Remove string values that aren't constants or subclasses of AR
+        @class_names.delete_if { |k,klass|
+          unless klass.is_a? Class
+            klass = klass.safe_constantize
+            ActiveSupport::Deprecation.warn("The ability to pass in strings as a class name to `set_fixture_class` will be removed in Rails 4.2. Use the class itself instead.")
+          end
+          !insert_class(@class_names, k, klass)
+        }
+      end
+
+      def [](fs_name)
+        @class_names.fetch(fs_name) {
+          klass = default_fixture_model(fs_name, @config).safe_constantize
+          insert_class(@class_names, fs_name, klass)
+        }
+      end
+
+      private
+
+      def insert_class(class_names, name, klass)
+        # We only want to deal with AR objects.
+        if klass && klass < ActiveRecord::Base
+          class_names[name] = klass
+        else
+          class_names[name] = nil
+        end
+      end
+
+      def default_fixture_model(fs_name, config)
+        ActiveRecord::FixtureSet.default_fixture_model_name(fs_name, config)
+      end
+    end
+
+    def self.create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base)
       fixture_set_names = Array(fixture_set_names).map(&:to_s)
-      class_names = class_names.stringify_keys
+      class_names = ClassCache.new class_names, config
 
       # FIXME: Apparently JK uses this.
       connection = block_given? ? yield : ActiveRecord::Base.connection
@@ -458,10 +507,12 @@ module ActiveRecord
           fixtures_map = {}
 
           fixture_sets = files_to_read.map do |fs_name|
+            klass = class_names[fs_name]
+            conn = klass ? klass.connection : connection
             fixtures_map[fs_name] = new( # ActiveRecord::FixtureSet.new
-              connection,
+              conn,
               fs_name,
-              class_names[fs_name] || default_fixture_model_name(fs_name),
+              klass,
               ::File.join(fixtures_directory, fs_name))
           end
 
@@ -481,12 +532,10 @@ module ActiveRecord
                   conn.insert_fixture(row, fixture_set_name)
                 end
               end
-            end
 
-            # Cap primary key sequences to max(pk).
-            if connection.respond_to?(:reset_pk_sequence!)
-              fixture_sets.each do |fs|
-                connection.reset_pk_sequence!(fs.table_name)
+              # Cap primary key sequences to max(pk).
+              if conn.respond_to?(:reset_pk_sequence!)
+                conn.reset_pk_sequence!(fs.table_name)
               end
             end
           end
@@ -503,27 +552,36 @@ module ActiveRecord
       Zlib.crc32(label.to_s) % MAX_ID
     end
 
-    attr_reader :table_name, :name, :fixtures, :model_class
+    # Superclass for the evaluation contexts used by ERB fixtures.
+    def self.context_class
+      @context_class ||= Class.new
+    end
+
+    attr_reader :table_name, :name, :fixtures, :model_class, :config
 
-    def initialize(connection, name, class_name, path)
-      @fixtures = {} # Ordered hash
+    def initialize(connection, name, class_name, path, config = ActiveRecord::Base)
       @name     = name
       @path     = path
+      @config   = config
+      @model_class = nil
+
+      if class_name.is_a?(String)
+        ActiveSupport::Deprecation.warn("The ability to pass in strings as a class name to `FixtureSet.new` will be removed in Rails 4.2. Use the class itself instead.")
+      end
 
       if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
         @model_class = class_name
       else
-        @model_class = class_name.constantize rescue nil
+        @model_class = class_name.safe_constantize if class_name
       end
 
-      @connection  = ( model_class.respond_to?(:connection) ?
-                       model_class.connection : connection )
+      @connection  = connection
 
       @table_name = ( model_class.respond_to?(:table_name) ?
                       model_class.table_name :
-                      self.class.default_fixture_table_name(name) )
+                      self.class.default_fixture_table_name(name, config) )
 
-      read_fixture_files
+      @fixtures = read_fixture_files path, @model_class
     end
 
     def [](x)
@@ -542,10 +600,10 @@ module ActiveRecord
       fixtures.size
     end
 
-    # Return a hash of rows to be inserted. The key is the table, the value is
+    # Returns a hash of rows to be inserted. The key is the table, the value is
     # a list of rows to insert to that table.
     def table_rows
-      now = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+      now = config.default_timezone == :utc ? Time.now.utc : Time.now
       now = now.to_s(:db)
 
       # allow a standard key to be used for doing defaults in YAML
@@ -557,7 +615,7 @@ module ActiveRecord
       rows[table_name] = fixtures.map do |label, fixture|
         row = fixture.to_hash
 
-        if model_class && model_class < ActiveRecord::Base
+        if model_class
           # fill in timestamp columns if they aren't specified and the model is set to record_timestamps
           if model_class.record_timestamps
             timestamp_column_names.each do |c_name|
@@ -567,7 +625,7 @@ module ActiveRecord
 
           # interpolate the fixture label
           row.each do |key, value|
-            row[key] = label if value == "$LABEL"
+            row[key] = label if "$LABEL" == value
           end
 
           # generate a primary key if necessary
@@ -583,7 +641,7 @@ module ActiveRecord
               model_class
             end
 
-          reflection_class.reflect_on_all_associations.each do |association|
+          reflection_class._reflections.values.each do |association|
             case association.macro
             when :belongs_to
               # Do not replace association name with association foreign key if they are named the same
@@ -597,14 +655,9 @@ module ActiveRecord
 
                 row[fk_name] = ActiveRecord::FixtureSet.identify(value)
               end
-            when :has_and_belongs_to_many
-              if (targets = row.delete(association.name.to_s))
-                targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
-                table_name = association.join_table
-                rows[table_name].concat targets.map { |target|
-                  { association.foreign_key             => row[primary_key_name],
-                    association.association_foreign_key => ActiveRecord::FixtureSet.identify(target) }
-                }
+            when :has_many
+              if association.options[:through]
+                add_join_records(rows, row, HasManyThroughProxy.new(association))
               end
             end
           end
@@ -615,11 +668,54 @@ module ActiveRecord
       rows
     end
 
+    class ReflectionProxy # :nodoc:
+      def initialize(association)
+        @association = association
+      end
+
+      def join_table
+        @association.join_table
+      end
+
+      def name
+        @association.name
+      end
+    end
+
+    class HasManyThroughProxy < ReflectionProxy # :nodoc:
+      def rhs_key
+        @association.foreign_key
+      end
+
+      def lhs_key
+        @association.through_reflection.foreign_key
+      end
+
+      def join_table
+        @association.through_reflection.table_name
+      end
+    end
+
     private
       def primary_key_name
         @primary_key_name ||= model_class && model_class.primary_key
       end
 
+      def add_join_records(rows, row, association)
+        # This is the case when the join table has no fixtures file
+        if (targets = row.delete(association.name.to_s))
+          table_name = association.join_table
+          lhs_key    = association.lhs_key
+          rhs_key    = association.rhs_key
+
+          targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
+          rows[table_name].concat targets.map { |target|
+            { lhs_key => row[primary_key_name],
+              rhs_key => ActiveRecord::FixtureSet.identify(target) }
+          }
+        end
+      end
+
       def has_primary_key_column?
         @has_primary_key_column ||= primary_key_name &&
           model_class.columns.any? { |c| c.name == primary_key_name }
@@ -638,12 +734,12 @@ module ActiveRecord
         @column_names ||= @connection.columns(@table_name).collect { |c| c.name }
       end
 
-      def read_fixture_files
-        yaml_files = Dir["#{@path}/{**,*}/*.yml"].select { |f|
+      def read_fixture_files(path, model_class)
+        yaml_files = Dir["#{path}/{**,*}/*.yml"].select { |f|
           ::File.file?(f)
-        } + [yaml_file_path]
+        } + [yaml_file_path(path)]
 
-        yaml_files.each do |file|
+        yaml_files.each_with_object({}) do |file, fixtures|
           FixtureSet::File.open(file) do |fh|
             fh.each do |fixture_name, row|
               fixtures[fixture_name] = ActiveRecord::Fixture.new(row, model_class)
@@ -652,8 +748,8 @@ module ActiveRecord
         end
       end
 
-      def yaml_file_path
-        "#{@path}.yml"
+      def yaml_file_path(path)
+        "#{path}.yml"
       end
 
   end
@@ -696,7 +792,7 @@ module ActiveRecord
 
     def find
       if model_class
-        model_class.find(fixture[model_class.primary_key])
+        model_class.unscoped.find(fixture[model_class.primary_key])
       else
         raise FixtureClassNotFound, "No class attached to find."
       end
@@ -725,14 +821,16 @@ module ActiveRecord
       class_attribute :use_transactional_fixtures
       class_attribute :use_instantiated_fixtures # true, false, or :no_instances
       class_attribute :pre_loaded_fixtures
+      class_attribute :config
 
       self.fixture_table_names = []
       self.use_transactional_fixtures = true
       self.use_instantiated_fixtures = false
       self.pre_loaded_fixtures = false
+      self.config = ActiveRecord::Base
 
       self.fixture_class_names = Hash.new do |h, fixture_set_name|
-        h[fixture_set_name] = ActiveRecord::FixtureSet.default_fixture_model_name(fixture_set_name)
+        h[fixture_set_name] = ActiveRecord::FixtureSet.default_fixture_model_name(fixture_set_name, self.config)
       end
     end
 
@@ -745,13 +843,6 @@ module ActiveRecord
       #                     'namespaced/fixture' => Another::Model
       #
       # The keys must be the fixture names, that coincide with the short paths to the fixture files.
-      #--
-      # It is also possible to pass the class name instead of the class:
-      #   set_fixture_class 'some_fixture' => 'SomeModel'
-      # I think this option is redundant, i propose to deprecate it.
-      # Isn't it easier to always pass the class itself?
-      # (2011-12-20 alexeymuranov)
-      #++
       def set_fixture_class(class_names = {})
         self.fixture_class_names = self.fixture_class_names.merge(class_names.stringify_keys)
       end
@@ -765,22 +856,22 @@ module ActiveRecord
         end
 
         self.fixture_table_names |= fixture_set_names
-        require_fixture_classes(fixture_set_names)
+        require_fixture_classes(fixture_set_names, self.config)
         setup_fixture_accessors(fixture_set_names)
       end
 
       def try_to_load_dependency(file_name)
         require_dependency file_name
       rescue LoadError => e
-        # Let's hope the developer has included it
-        # Let's warn in case this is a subdependency, otherwise
-        # subdependency error messages are totally cryptic
-        if ActiveRecord::Base.logger
-          ActiveRecord::Base.logger.warn("Unable to load #{file_name}, underlying cause #{e.message} \n\n #{e.backtrace.join("\n")}")
+        unless fixture_class_names.key?(file_name.pluralize)
+          if ActiveRecord::Base.logger
+            ActiveRecord::Base.logger.warn("Unable to load #{file_name}, make sure you added it to ActiveSupport::TestCase.set_fixture_class")
+            ActiveRecord::Base.logger.warn("underlying cause #{e.message} \n\n #{e.backtrace.join("\n")}")
+          end
         end
       end
 
-      def require_fixture_classes(fixture_set_names = nil)
+      def require_fixture_classes(fixture_set_names = nil, config = ActiveRecord::Base)
         if fixture_set_names
           fixture_set_names = fixture_set_names.map { |n| n.to_s }
         else
@@ -788,7 +879,7 @@ module ActiveRecord
         end
 
         fixture_set_names.each do |file_name|
-          file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
+          file_name = file_name.singularize if config.pluralize_table_names
           try_to_load_dependency(file_name)
         end
       end
@@ -840,9 +931,7 @@ module ActiveRecord
         !self.class.uses_transaction?(method_name)
     end
 
-    def setup_fixtures
-      return if ActiveRecord::Base.configurations.blank?
-
+    def setup_fixtures(config = ActiveRecord::Base)
       if pre_loaded_fixtures && !use_transactional_fixtures
         raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
       end
@@ -856,7 +945,7 @@ module ActiveRecord
         if @@already_loaded_fixtures[self.class]
           @loaded_fixtures = @@already_loaded_fixtures[self.class]
         else
-          @loaded_fixtures = load_fixtures
+          @loaded_fixtures = load_fixtures(config)
           @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
         @fixture_connections = enlist_fixture_connections
@@ -867,16 +956,14 @@ module ActiveRecord
       else
         ActiveRecord::FixtureSet.reset_cache
         @@already_loaded_fixtures[self.class] = nil
-        @loaded_fixtures = load_fixtures
+        @loaded_fixtures = load_fixtures(config)
       end
 
       # Instantiate fixtures for every test if requested.
-      instantiate_fixtures if use_instantiated_fixtures
+      instantiate_fixtures(config) if use_instantiated_fixtures
     end
 
     def teardown_fixtures
-      return if ActiveRecord::Base.configurations.blank?
-
       # Rollback changes if a transaction is active.
       if run_in_transaction?
         @fixture_connections.each do |connection|
@@ -895,19 +982,19 @@ module ActiveRecord
     end
 
     private
-      def load_fixtures
-        fixtures = ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names)
+      def load_fixtures(config)
+        fixtures = ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config)
         Hash[fixtures.map { |f| [f.name, f] }]
       end
 
       # for pre_loaded_fixtures, only require the classes once. huge speed improvement
       @@required_fixture_classes = false
 
-      def instantiate_fixtures
+      def instantiate_fixtures(config)
         if pre_loaded_fixtures
           raise RuntimeError, 'Load fixtures before instantiating them.' if ActiveRecord::FixtureSet.all_loaded_fixtures.empty?
           unless @@required_fixture_classes
-            self.class.require_fixture_classes ActiveRecord::FixtureSet.all_loaded_fixtures.keys
+            self.class.require_fixture_classes ActiveRecord::FixtureSet.all_loaded_fixtures.keys, config
             @@required_fixture_classes = true
           end
           ActiveRecord::FixtureSet.instantiate_all_loaded_fixtures(self, load_instances?)
@@ -924,3 +1011,13 @@ module ActiveRecord
       end
   end
 end
+
+class ActiveRecord::FixtureSet::RenderContext # :nodoc:
+  def self.create_subclass
+    Class.new ActiveRecord::FixtureSet.context_class do
+      def get_binding
+        binding()
+      end
+    end
+  end
+end

data/lib/active_record/gem_version.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 4
+    MINOR = 1
+    TINY  = 16
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_record/inheritance.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      # Determine whether to store the full constant name including namespace when using STI
+      # Determines whether to store the full constant name including namespace when using STI.
       class_attribute :store_full_sti_class, instance_writer: false
       self.store_full_sti_class = true
     end
@@ -13,10 +13,10 @@ module ActiveRecord
     module ClassMethods
       # Determines if one of the attributes passed in is the inheritance column,
       # and if the inheritance column is attr accessible, it initializes an
-      # instance of the given subclass instead of the base class
+      # instance of the given subclass instead of the base class.
       def new(*args, &block)
         if abstract_class? || self == Base
-          raise NotImplementedError, "#{self} is an abstract class and can not be instantiated."
+          raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
         end
 
         attrs = args.first
@@ -31,7 +31,8 @@ module ActiveRecord
         end
       end
 
-      # True if this isn't a concrete subclass needing a STI type condition.
+      # Returns +true+ if this does not need STI type condition. Returns
+      # +false+ if STI type condition needs to be applied.
       def descends_from_active_record?
         if self == Base
           false
@@ -48,10 +49,12 @@ module ActiveRecord
       end
 
       def symbolized_base_class
+        ActiveSupport::Deprecation.warn("ActiveRecord::Base.symbolized_base_class is deprecated and will be removed without replacement.")
         @symbolized_base_class ||= base_class.to_s.to_sym
       end
 
       def symbolized_sti_name
+        ActiveSupport::Deprecation.warn("ActiveRecord::Base.symbolized_sti_name is deprecated and will be removed without replacement.")
         @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
       end
 
@@ -120,13 +123,14 @@ module ActiveRecord
             begin
               constant = ActiveSupport::Dependencies.constantize(candidate)
               return constant if candidate == constant.to_s
-            rescue NameError => e
-              # We don't want to swallow NoMethodError < NameError errors
-              raise e unless e.instance_of?(NameError)
+            # We don't want to swallow NoMethodError < NameError errors
+            rescue NoMethodError
+              raise
+            rescue NameError
             end
           end
 
-          raise NameError, "uninitialized constant #{candidates.first}"
+          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
         end
       end
 
@@ -162,7 +166,7 @@ module ActiveRecord
       end
 
       def type_condition(table = arel_table)
-        sti_column = table[inheritance_column.to_sym]
+        sti_column = table[inheritance_column]
         sti_names  = ([self] + descendants).map { |model| model.sti_name }
 
         sti_column.in(sti_names)
@@ -191,8 +195,18 @@ module ActiveRecord
       end
     end
 
+    def initialize_dup(other)
+      super
+      ensure_proper_type
+    end
+
     private
 
+    def initialize_internals_callback
+      super
+      ensure_proper_type
+    end
+
     # Sets the attribute used for single table inheritance to this class name if this is not the
     # ActiveRecord::Base descendant.
     # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to

data/lib/active_record/integration.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/string/filters'
+
 module ActiveRecord
   module Integration
     extend ActiveSupport::Concern
@@ -45,10 +47,19 @@ module ActiveRecord
     #   Product.new.cache_key     # => "products/new"
     #   Product.find(5).cache_key # => "products/5" (updated_at not available)
     #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
-    def cache_key
+    #
+    # You can also pass a list of named timestamps, and the newest in the list will be
+    # used to generate the key:
+    #
+    #   Person.find(5).cache_key(:updated_at, :last_reviewed_at)
+    def cache_key(*timestamp_names)
       case
       when new_record?
         "#{self.class.model_name.cache_key}/new"
+      when timestamp_names.any?
+        timestamp = max_updated_column_timestamp(timestamp_names)
+        timestamp = timestamp.utc.to_s(cache_timestamp_format)
+        "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
       when timestamp = max_updated_column_timestamp
         timestamp = timestamp.utc.to_s(cache_timestamp_format)
         "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
@@ -56,5 +67,47 @@ module ActiveRecord
         "#{self.class.model_name.cache_key}/#{id}"
       end
     end
+
+    module ClassMethods
+      # Defines your model's +to_param+ method to generate "pretty" URLs
+      # using +method_name+, which can be any attribute or method that
+      # responds to +to_s+.
+      #
+      #   class User < ActiveRecord::Base
+      #     to_param :name
+      #   end
+      #
+      #   user = User.find_by(name: 'Fancy Pants')
+      #   user.id         # => 123
+      #   user_path(user) # => "/users/123-fancy-pants"
+      #
+      # Values longer than 20 characters will be truncated. The value
+      # is truncated word by word.
+      #
+      #   user = User.find_by(name: 'David HeinemeierHansson')
+      #   user.id         # => 125
+      #   user_path(user) # => "/users/125-david"
+      #
+      # Because the generated param begins with the record's +id+, it is
+      # suitable for passing to +find+. In a controller, for example:
+      #
+      #   params[:id]               # => "123-fancy-pants"
+      #   User.find(params[:id]).id # => 123
+      def to_param(method_name = nil)
+        if method_name.nil?
+          super()
+        else
+          define_method :to_param do
+            if (default = super()) &&
+                 (result = send(method_name).to_s).present? &&
+                   (param = result.squish.truncate(20, separator: /\s/, omission: nil).parameterize).present?
+              "#{default}-#{param}"
+            else
+              default
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/active_record/locking/optimistic.rb

@@ -66,7 +66,7 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def update_record(attribute_names = @attributes.keys) #:nodoc:
+        def _update_record(attribute_names = @attributes.keys) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
 
@@ -84,7 +84,10 @@ module ActiveRecord
               relation.table[self.class.primary_key].eq(id).and(
                 relation.table[lock_col].eq(self.class.quote_value(previous_lock_value, column_for_attribute(lock_col)))
               )
-            ).arel.compile_update(arel_attributes_with_values_for_update(attribute_names))
+            ).arel.compile_update(
+              arel_attributes_with_values_for_update(attribute_names),
+              self.class.primary_key
+            )
 
             affected_rows = self.class.connection.update stmt
 
@@ -138,6 +141,7 @@ module ActiveRecord
 
         # Set the column to use for optimistic locking. Defaults to +lock_version+.
         def locking_column=(value)
+          @column_defaults = nil
           @locking_column = value.to_s
         end
 
@@ -149,6 +153,7 @@ module ActiveRecord
 
         # Quote the column name used for optimistic locking.
         def quoted_locking_column
+          ActiveSupport::Deprecation.warn "ActiveRecord::Base.quoted_locking_column is deprecated and will be removed in Rails 4.2 or later."
           connection.quote_column_name(locking_column)
         end