activerecord 3.2.13 → 3.2.14.rc1

data/CHANGELOG.md

@@ -1,11 +1,147 @@
-## Rails 3.2.13 (Feb 17, 2013) ##
+## Rails 3.2.14.rc1 (Jul 8, 2013) ##
+
+*   Do not shallow the original exception in `exec_cache` on PostgreSQL adapter.
+
+    Fixes #11260.
+
+    *Rafael Mendonça França*
+
+*   Fix `ActiveRecord::Store` incorrectly tracking changes of its attributes.
+    Fixes #10373.
+
+    *Janko Marohnić*
+
+*   Fix a bug that prevented the use of the default STI inheritance column
+    (ActiveRecord::Base.inheritance_column = 'some_column'.)
+
+    *chapmajs + Takehiro Adachi*
+
+*   Fix mysql2 adapter raises the correct exception when executing a query on a
+    closed connection.
+
+    *Yves Senn*
+
+*   Fixes bug where `Company.new.contract_ids` would incorrectly load
+    all non-associated contracts.
+
+    Example:
+
+        company = Company.new # Company has many :contracts
+
+        # before
+        company.contract_ids # => SELECT ... WHERE `contracts`.`company_id` IS NULL
+
+        # after
+        company.contract_ids # => []
+
+    *Jared Armstrong*
+
+*   Fix the `:primary_key` option for `has_many` associations.
+    Fixes #10693.
+
+    *Yves Senn*
+
+*   fixes bug introduced by #3329.  Now, when autosaving associations,
+    deletions happen before inserts and saves.  This prevents a 'duplicate
+    unique value' database error that would occur if a record being created had
+    the same value on a unique indexed field as that of a record being destroyed.
+
+    Backport of #10417
+
+    *Johnny Holton*
+
+*   Fix that under some conditions, Active Record could produce invalid SQL of the sort:
+    "SELECT DISTINCT DISTINCT".
+
+    Backport of #6792.
+
+    *Ben Woosley*
+
+*   Require `ActiveRecord::Base` in railtie hooks for rake_tasks, console and runner to
+    avoid circular constant loading issues.
+
+    Backport #7695.
+
+    Fixes #7683 and #882
+
+    *Ben Holley*
+
+*   Maintain context for joins within ActiveRecord::Relation merges.
+    Backport #10164.
+
+    *Neeraj Singh + Andrew Horner*
+
+*   Make sure the `EXPLAIN` command is never triggered by a `select_db` call.
+
+    *Daniel Schierbeck*
+
+*   Revert changes on `pluck` that was ignoring the select clause when the relation already
+    has one. This caused a regression since it changed the behavior in a stable release.
+
+    Fixes #9777.
+
+    *Rafael Mendonça França*
+
+*   Confirm a record has not already been destroyed before decrementing counter cache.
+
+    *Ben Tucker*
+
+*   Default values for PostgreSQL bigint types now get parsed and dumped to the
+    schema correctly.
+    Backport #10098.
+
+    *Erik Peterson*
+
+*   Removed warning when `auto_explain_threshold_in_seconds` is set and the
+    connection adapter doesn't support explain.
+    This is causing a regression since the Active Record Railtie is trying to
+    connect to the development database in the application boot.
+
+    *Rafael Mendonça França*
+
+*   Do not reset `inheritance_column` when it's set explicitly.
+    Backport of #5327.
+
+    *kennyj + Fred Wu*
+
+*   Fix a problem wrong exception is occured
+    when raising no translatable exception in PostgreSQL.
+
+    *kennyj*
+
+*   Resets the postgres search path in the structure.sql after the structure
+    is dumped in order to find schema_migrations table when multiples schemas
+    are used.
+    Fixes #9796.
+
+    *Juan M. Cuello + Dembskiy Alexander*
+
+*   Reload the association target if it's stale. `@stale_state` should be nil
+    when a model isn't saved.
+    Fixes #7526.
+
+    *Larry Lv*
+
+*   Don't read CSV files during execution of `db:fixtures:load`. CSV support for
+    fixtures was removed some time ago but the task was still loading them, even
+    though later the code was looking for the related yaml file instead.
+
+    *kennyj*
+
+
+## Rails 3.2.13 (Mar 18, 2013) ##
+
+*   Chaining multiple preloaded scopes will correctly preload all the scopes
+    at the same time.
+
+    *Chris Geihsler*
 
 *   Reverted 921a296a3390192a71abeec6d9a035cc6d1865c8, 'Quote numeric values
     compared to string columns.' This caused several regressions.
 
     *Steve Klabnik*
 
-*   Fix overriding of attributes by default_scope on `ActiveRecord::Base#dup`.
+*   Fix overriding of attributes by `default_scope` on `ActiveRecord::Base#dup`.
 
     *Hiroshige UMINO*
 
@@ -223,6 +359,16 @@
 
     *Victor Costan*
 
+*   `#pluck` can be used on a relation with `select` clause.
+    Fixes #7551.
+    Backport of #8176.
+
+    Example:
+
+        Topic.select([:approved, :id]).order(:id).pluck(:id)
+
+    *Yves Senn*
+
 *   Use `nil?` instead of `blank?` to check whether dynamic finder with a bang
     should raise RecordNotFound.
     Fixes #7238.

data/lib/active_record/associations/association.rb

@@ -46,6 +46,7 @@ module ActiveRecord
         @loaded = false
         IdentityMap.remove(target) if IdentityMap.enabled? && target
         @target = nil
+        @stale_state = nil
       end
 
       # Reloads the \target and returns +self+ on success.
@@ -128,16 +129,21 @@ module ActiveRecord
       # This method is abstract in the sense that it relies on +find_target+,
       # which is expected to be provided by descendants.
       #
-      # If the \target is already \loaded it is just returned. Thus, you can call
-      # +load_target+ unconditionally to get the \target.
+      # If the \target is stale(the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to.), force reload the \target.
+      #
+      # Otherwise if the \target is already \loaded it is just returned. Thus, you can
+      # call +load_target+ unconditionally to get the \target.
       #
       # ActiveRecord::RecordNotFound is rescued within the method, and it is
       # not reraised. The proxy is \reset and +nil+ is the return value.
       def load_target
-        if find_target?
+        if (@stale_state && stale_target?) || find_target?
           begin
             if IdentityMap.enabled? && association_class && association_class.respond_to?(:base_class)
               @target = IdentityMap.get(association_class, owner[reflection.foreign_key])
+            elsif @stale_state && stale_target?
+              @target = find_target
             end
           rescue NameError
             nil

data/lib/active_record/associations/belongs_to_association.rb

@@ -72,7 +72,7 @@ module ActiveRecord
         end
 
         def stale_state
-          owner[reflection.foreign_key].to_s
+          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
         end
     end
   end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -27,7 +27,8 @@ module ActiveRecord
         end
 
         def stale_state
-          [super, owner[reflection.foreign_type].to_s]
+          foreign_key = super
+          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
         end
     end
   end

data/lib/active_record/associations/builder/belongs_to.rb

@@ -34,7 +34,10 @@ module ActiveRecord::Associations::Builder
         method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
         mixin.redefine_method(method_name) do
           record = send(name)
-          record.class.decrement_counter(cache_column, record.id) unless record.nil?
+
+          if record && !self.destroyed?
+            record.class.decrement_counter(cache_column, record.id)
+          end
         end
         model.before_destroy(method_name)
 

data/lib/active_record/associations/builder/belongs_to.rb.orig

@@ -0,0 +1,95 @@
+require 'active_support/core_ext/object/inclusion'
+
+module ActiveRecord::Associations::Builder
+  class BelongsTo < SingularAssociation #:nodoc:
+    self.macro = :belongs_to
+
+    self.valid_options += [:foreign_type, :polymorphic, :touch]
+
+    def constructable?
+      !options[:polymorphic]
+    end
+
+    def build
+      reflection = super
+      add_counter_cache_callbacks(reflection) if options[:counter_cache]
+      add_touch_callbacks(reflection)         if options[:touch]
+      configure_dependency
+      reflection
+    end
+
+    private
+
+      def add_counter_cache_callbacks(reflection)
+        cache_column = reflection.counter_cache_column
+        name         = self.name
+
+<<<<<<< HEAD
+        method_name = "belongs_to_counter_cache_after_create_for_#{name}"
+        mixin.redefine_method(method_name) do
+          record = send(name)
+          record.class.increment_counter(cache_column, record.id) unless record.nil?
+=======
+        def belongs_to_counter_cache_before_destroy_for_#{name}
+          unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == #{foreign_key.to_sym.inspect}
+            record = #{name}
+            if record && !self.destroyed?
+              record.class.decrement_counter(:#{cache_column}, record.id)
+            end
+          end
+>>>>>>> 19d32e8... Merge pull request #10489 from greenriver/ar_counter_cache_multiple_destroy
+        end
+        model.after_create(method_name)
+
+        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
+        mixin.redefine_method(method_name) do
+          record = send(name)
+          record.class.decrement_counter(cache_column, record.id) unless record.nil?
+        end
+        model.before_destroy(method_name)
+
+        model.send(:module_eval,
+          "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
+        )
+      end
+
+      def add_touch_callbacks(reflection)
+        name        = self.name
+        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
+        touch       = options[:touch]
+
+        mixin.redefine_method(method_name) do
+          record = send(name)
+
+          unless record.nil?
+            if touch == true
+              record.touch
+            else
+              record.touch(touch)
+            end
+          end
+        end
+
+        model.after_save(method_name)
+        model.after_touch(method_name)
+        model.after_destroy(method_name)
+      end
+
+      def configure_dependency
+        if options[:dependent]
+          unless options[:dependent].in?([:destroy, :delete])
+            raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
+          end
+
+          method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
+          model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+            def #{method_name}
+              association = #{name}
+              association.#{options[:dependent]} if association
+            end
+          eoruby
+          model.after_destroy method_name
+        end
+      end
+  end
+end

data/lib/active_record/associations/collection_association.rb

@@ -43,7 +43,7 @@ module ActiveRecord
 
       # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
       def ids_reader
-        if loaded? || options[:finder_sql]
+        if owner.new_record? || loaded? || options[:finder_sql]
           load_target.map do |record|
             record.send(reflection.association_primary_key)
           end

data/lib/active_record/associations/has_many_association.rb

@@ -89,8 +89,7 @@ module ActiveRecord
             records.each { |r| r.destroy }
             update_counter(-records.length) unless inverse_updates_counter_cache?
           else
-            keys  = records.map { |r| r[reflection.association_primary_key] }
-            scope = scoped.where(reflection.association_primary_key => keys)
+            scope = self.scoped.where(reflection.klass.primary_key => records)
 
             if method == :delete_all
               update_counter(-scope.delete_all)

data/lib/active_record/associations/has_many_association.rb.orig

@@ -0,0 +1,116 @@
+module ActiveRecord
+  # = Active Record Has Many Association
+  module Associations
+    # This is the proxy that handles a has many association.
+    #
+    # If the association has a <tt>:through</tt> option further specialization
+    # is provided by its child HasManyThroughAssociation.
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+
+      def insert_record(record, validate = true, raise = false)
+        set_owner_attributes(record)
+
+        if raise
+          record.save!(:validate => validate)
+        else
+          record.save(:validate => validate)
+        end
+      end
+
+      private
+
+        # Returns the number of records in this collection.
+        #
+        # If the association has a counter cache it gets that value. Otherwise
+        # it will attempt to do a count via SQL, bounded to <tt>:limit</tt> if
+        # there's one. Some configuration options like :group make it impossible
+        # to do an SQL count, in those cases the array count will be used.
+        #
+        # That does not depend on whether the collection has already been loaded
+        # or not. The +size+ method is the one that takes the loaded flag into
+        # account and delegates to +count_records+ if needed.
+        #
+        # If the collection is empty the target is set to an empty array and
+        # the loaded flag is set to true as well.
+        def count_records
+          count = if has_cached_counter?
+            owner.send(:read_attribute, cached_counter_attribute_name)
+          elsif options[:counter_sql] || options[:finder_sql]
+            reflection.klass.count_by_sql(custom_counter_sql)
+          else
+            scoped.count
+          end
+
+          # If there's nothing in the database and @target has no new records
+          # we are certain the current target is an empty array. This is a
+          # documented side-effect of the method that may avoid an extra SELECT.
+          @target ||= [] and loaded! if count == 0
+
+          [options[:limit], count].compact.min
+        end
+
+        def has_cached_counter?(reflection = reflection)
+          owner.attribute_present?(cached_counter_attribute_name(reflection))
+        end
+
+        def cached_counter_attribute_name(reflection = reflection)
+          "#{reflection.name}_count"
+        end
+
+        def update_counter(difference, reflection = reflection)
+          if has_cached_counter?(reflection)
+            counter = cached_counter_attribute_name(reflection)
+            owner.class.update_counters(owner.id, counter => difference)
+            owner[counter] += difference
+            owner.changed_attributes.delete(counter) # eww
+          end
+        end
+
+        # This shit is nasty. We need to avoid the following situation:
+        #
+        #   * An associated record is deleted via record.destroy
+        #   * Hence the callbacks run, and they find a belongs_to on the record with a
+        #     :counter_cache options which points back at our owner. So they update the
+        #     counter cache.
+        #   * In which case, we must make sure to *not* update the counter cache, or else
+        #     it will be decremented twice.
+        #
+        # Hence this method.
+        def inverse_updates_counter_cache?(reflection = reflection)
+          counter_name = cached_counter_attribute_name(reflection)
+          reflection.klass.reflect_on_all_associations(:belongs_to).any? { |inverse_reflection|
+            inverse_reflection.counter_cache_column == counter_name
+          }
+        end
+
+        # Deletes the records according to the <tt>:dependent</tt> option.
+        def delete_records(records, method)
+          if method == :destroy
+            records.each { |r| r.destroy }
+            update_counter(-records.length) unless inverse_updates_counter_cache?
+          else
+<<<<<<< HEAD
+            keys  = records.map { |r| r[reflection.association_primary_key] }
+            scope = scoped.where(reflection.association_primary_key => keys)
+=======
+            if records == :all
+              scope = self.scope
+            else
+              scope = self.scope.where(reflection.klass.primary_key => records)
+            end
+>>>>>>> 030d30d... Merge pull request #10713 from senny/10693_fix_primary_key_option_on_has_many
+
+            if method == :delete_all
+              update_counter(-scope.delete_all)
+            else
+              update_counter(-scope.update_all(reflection.foreign_key => nil))
+            end
+          end
+        end
+
+        def foreign_key_present?
+          owner.attribute_present?(reflection.association_primary_key)
+        end
+    end
+  end
+end