activerecord 4.1.15 → 4.2.11.3

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -19,7 +19,6 @@ module ActiveRecord
 
         def initialize(base_klass, children)
           @base_klass = base_klass
-          @column_names_with_alias = nil
           @children = children
         end
 

data/lib/active_record/associations/preloader.rb

@@ -2,33 +2,42 @@ module ActiveRecord
   module Associations
     # Implements the details of eager loading of Active Record associations.
     #
-    # Note that 'eager loading' and 'preloading' are actually the same thing.
-    # However, there are two different eager loading strategies.
+    # Suppose that you have the following two Active Record models:
     #
-    # The first one is by using table joins. This was only strategy available
-    # prior to Rails 2.1. Suppose that you have an Author model with columns
-    # 'name' and 'age', and a Book model with columns 'name' and 'sales'. Using
-    # this strategy, Active Record would try to retrieve all data for an author
-    # and all of its books via a single query:
+    #   class Author < ActiveRecord::Base
+    #     # columns: name, age
+    #     has_many :books
+    #   end
     #
-    #   SELECT * FROM authors
-    #   LEFT OUTER JOIN books ON authors.id = books.author_id
-    #   WHERE authors.name = 'Ken Akamatsu'
+    #   class Book < ActiveRecord::Base
+    #     # columns: title, sales, author_id
+    #   end
     #
-    # However, this could result in many rows that contain redundant data. After
-    # having received the first row, we already have enough data to instantiate
-    # the Author object. In all subsequent rows, only the data for the joined
-    # 'books' table is useful; the joined 'authors' data is just redundant, and
-    # processing this redundant data takes memory and CPU time. The problem
-    # quickly becomes worse and worse as the level of eager loading increases
-    # (i.e. if Active Record is to eager load the associations' associations as
-    # well).
+    # When you load an author with all associated books Active Record will make
+    # multiple queries like this:
+    #
+    #   Author.includes(:books).where(name: ['bell hooks', 'Homer']).to_a
+    #
+    #   => SELECT `authors`.* FROM `authors` WHERE `name` IN ('bell hooks', 'Homer')
+    #   => SELECT `books`.* FROM `books` WHERE `author_id` IN (2, 5)
+    #
+    # Active Record saves the ids of the records from the first query to use in
+    # the second. Depending on the number of associations involved there can be
+    # arbitrarily many SQL queries made.
+    #
+    # However, if there is a WHERE clause that spans across tables Active
+    # Record will fall back to a slightly more resource-intensive single query:
+    #
+    #   Author.includes(:books).where(books: {title: 'Illiad'}).to_a
+    #   => SELECT `authors`.`id` AS t0_r0, `authors`.`name` AS t0_r1, `authors`.`age` AS t0_r2,
+    #             `books`.`id`   AS t1_r0, `books`.`title`  AS t1_r1, `books`.`sales` AS t1_r2
+    #      FROM `authors`
+    #      LEFT OUTER JOIN `books` ON `authors`.`id` =  `books`.`author_id`
+    #      WHERE `books`.`title` = 'Illiad'
+    #
+    # This could result in many rows that contain redundant data and it performs poorly at scale
+    # and is therefore only used when necessary.
     #
-    # The second strategy is to use multiple database queries, one for each
-    # level of association. Since Rails 2.1, this is the default strategy. In
-    # situations where a table join is necessary (e.g. when the +:conditions+
-    # option references an association's column), it will fallback to the table
-    # join strategy.
     class Preloader #:nodoc:
       extend ActiveSupport::Autoload
 
@@ -80,7 +89,7 @@ module ActiveRecord
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
 
-      NULL_RELATION = Struct.new(:values).new({})
+      NULL_RELATION = Struct.new(:values, :bind_values).new({}, [])
 
       def preload(records, associations, preload_scope = nil)
         records       = Array.wrap(records).compact.uniq
@@ -151,7 +160,7 @@ module ActiveRecord
         h
       end
 
-      class AlreadyLoaded
+      class AlreadyLoaded # :nodoc:
         attr_reader :owners, :reflection
 
         def initialize(klass, owners, reflection, preload_scope)
@@ -166,7 +175,7 @@ module ActiveRecord
         end
       end
 
-      class NullPreloader
+      class NullPreloader # :nodoc:
         def self.new(klass, owners, reflection, preload_scope); self; end
         def self.run(preloader); end
         def self.preloaded_records; []; end
@@ -178,6 +187,7 @@ module ActiveRecord
         if owners.first.association(reflection.name).loaded?
           return AlreadyLoaded
         end
+        reflection.check_preloadable!
 
         case reflection.macro
         when :has_many

data/lib/active_record/associations/preloader/association.rb

@@ -104,13 +104,11 @@ module ActiveRecord
         end
 
         def association_key_type
-          column = @klass.column_types[association_key_name.to_s]
-          column && column.type
+          @klass.type_for_attribute(association_key_name.to_s).type
         end
 
         def owner_key_type
-          column = @model.column_types[owner_key_name.to_s]
-          column && column.type
+          @model.type_for_attribute(owner_key_name.to_s).type
         end
 
         def load_slices(slices)
@@ -134,27 +132,32 @@ module ActiveRecord
           scope = klass.unscoped
 
           values         = reflection_scope.values
+          reflection_binds = reflection_scope.bind_values
           preload_values = preload_scope.values
+          preload_binds  = preload_scope.bind_values
 
           scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
           scope.references_values = Array(values[:references]) + Array(preload_values[:references])
+          scope.bind_values       = (reflection_binds + preload_binds)
 
           scope._select!   preload_values[:select] || values[:select] || table[Arel.star]
           scope.includes! preload_values[:includes] || values[:includes]
+          scope.joins! preload_values[:joins] || values[:joins]
+          scope.order! preload_values[:order] || values[:order]
 
-          if preload_values.key? :order
-            scope.order! preload_values[:order]
-          else
-            if values.key? :order
-              scope.order! values[:order]
-            end
+          if preload_values[:reordering] || values[:reordering]
+            scope.reordering_value = true
+          end
+
+          if preload_values[:readonly] || values[:readonly]
+            scope.readonly!
           end
 
           if options[:as]
             scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
           end
 
-          scope.unscope_values = Array(values[:unscope])
+          scope.unscope_values = Array(values[:unscope]) + Array(preload_values[:unscope])
           klass.default_scoped.merge(scope)
         end
       end

data/lib/active_record/associations/preloader/through_association.rb

@@ -23,7 +23,7 @@ module ActiveRecord
 
           reset_association owners, through_reflection.name
 
-          middle_records = through_records.map { |(_,rec)| rec }.flatten
+          middle_records = through_records.flat_map { |(_,rec)| rec }
 
           preloaders = preloader.preload(middle_records,
                                          source_reflection.name,
@@ -63,7 +63,7 @@ module ActiveRecord
           should_reset = (through_scope != through_reflection.klass.unscoped) ||
              (reflection.options[:source_type] && through_reflection.collection?)
 
-          # Dont cache the association - we would only be caching a subset
+          # Don't cache the association - we would only be caching a subset
           if should_reset
             owners.each { |owner|
               owner.association(association_name).reset
@@ -81,10 +81,11 @@ module ActiveRecord
             unless reflection_scope.where_values.empty?
               scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
               scope.where_values    = reflection_scope.values[:where]
+              scope.bind_values     = reflection_scope.bind_values
             end
 
             scope.references! reflection_scope.values[:references]
-            scope.order! reflection_scope.values[:order] if scope.eager_loading?
+            scope = scope.order reflection_scope.values[:order] if scope.eager_loading?
           end
 
           scope

data/lib/active_record/associations/singular_association.rb

@@ -3,7 +3,7 @@ module ActiveRecord
     class SingularAssociation < Association #:nodoc:
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader(force_reload = false)
-        if force_reload
+        if force_reload && klass
           klass.uncached { reload }
         elsif !loaded? || stale_target?
           reload
@@ -38,8 +38,23 @@ module ActiveRecord
           scope.scope_for_create.stringify_keys.except(klass.primary_key)
         end
 
+        def get_records
+          return scope.limit(1).to_a if skip_statement_cache?
+
+          conn = klass.connection
+          sc = reflection.association_scope_cache(conn, owner) do
+            StatementCache.create(conn) { |params|
+              as = AssociationScope.create { params.bind }
+              target_scope.merge(as.scope(self, conn)).limit(1)
+            }
+          end
+
+          binds = AssociationScope.get_bind_values(owner, reflection.chain)
+          sc.execute binds, klass, klass.connection
+        end
+
         def find_target
-          if record = scope.take
+          if record = get_records.first
             set_inverse_instance record
           end
         end

data/lib/active_record/associations/through_association.rb

@@ -3,7 +3,7 @@ module ActiveRecord
   module Associations
     module ThroughAssociation #:nodoc:
 
-      delegate :source_reflection, :through_reflection, :chain, :to => :reflection
+      delegate :source_reflection, :through_reflection, :to => :reflection
 
       protected
 
@@ -13,14 +13,8 @@ module ActiveRecord
         #   2. To get the type conditions for any STI models in the chain
         def target_scope
           scope = super
-          chain.drop(1).each do |reflection|
+          reflection.chain.drop(1).each do |reflection|
             relation = reflection.klass.all
-
-            reflection_scope = reflection.scope
-            if reflection_scope && reflection_scope.arity.zero?
-              relation.merge!(reflection_scope)
-            end
-
             scope.merge!(
               relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
@@ -71,18 +65,17 @@ module ActiveRecord
         # Note: this does not capture all cases, for example it would be crazy to try to
         # properly support stale-checking for nested associations.
         def stale_state
-          if through_reflection.macro == :belongs_to
+          if through_reflection.belongs_to?
             owner[through_reflection.foreign_key] && owner[through_reflection.foreign_key].to_s
           end
         end
 
         def foreign_key_present?
-          through_reflection.macro == :belongs_to &&
-          !owner[through_reflection.foreign_key].nil?
+          through_reflection.belongs_to? && !owner[through_reflection.foreign_key].nil?
         end
 
         def ensure_mutable
-          if source_reflection.macro != :belongs_to
+          unless source_reflection.belongs_to?
             raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
           end
         end

data/lib/active_record/attribute.rb

@@ -0,0 +1,163 @@
+module ActiveRecord
+  class Attribute # :nodoc:
+    class << self
+      def from_database(name, value, type)
+        FromDatabase.new(name, value, type)
+      end
+
+      def from_user(name, value, type)
+        FromUser.new(name, value, type)
+      end
+
+      def with_cast_value(name, value, type)
+        WithCastValue.new(name, value, type)
+      end
+
+      def null(name)
+        Null.new(name)
+      end
+
+      def uninitialized(name, type)
+        Uninitialized.new(name, type)
+      end
+    end
+
+    attr_reader :name, :value_before_type_cast, :type
+
+    # This method should not be called directly.
+    # Use #from_database or #from_user
+    def initialize(name, value_before_type_cast, type)
+      @name = name
+      @value_before_type_cast = value_before_type_cast
+      @type = type
+    end
+
+    def value
+      # `defined?` is cheaper than `||=` when we get back falsy values
+      @value = original_value unless defined?(@value)
+      @value
+    end
+
+    def original_value
+      type_cast(value_before_type_cast)
+    end
+
+    def value_for_database
+      type.type_cast_for_database(value)
+    end
+
+    def changed_from?(old_value)
+      type.changed?(old_value, value, value_before_type_cast)
+    end
+
+    def changed_in_place_from?(old_value)
+      has_been_read? && type.changed_in_place?(old_value, value)
+    end
+
+    def with_value_from_user(value)
+      self.class.from_user(name, value, type)
+    end
+
+    def with_value_from_database(value)
+      self.class.from_database(name, value, type)
+    end
+
+    def with_cast_value(value)
+      self.class.with_cast_value(name, value, type)
+    end
+
+    def type_cast(*)
+      raise NotImplementedError
+    end
+
+    def initialized?
+      true
+    end
+
+    def came_from_user?
+      false
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        name == other.name &&
+        value_before_type_cast == other.value_before_type_cast &&
+        type == other.type
+    end
+
+    protected
+
+    def initialize_dup(other)
+      if defined?(@value) && @value.duplicable?
+        @value = @value.dup
+      end
+    end
+
+    private
+
+    def has_been_read?
+      defined?(@value)
+    end
+
+    class FromDatabase < Attribute # :nodoc:
+      def type_cast(value)
+        type.type_cast_from_database(value)
+      end
+    end
+
+    class FromUser < Attribute # :nodoc:
+      def type_cast(value)
+        type.type_cast_from_user(value)
+      end
+
+      def came_from_user?
+        true
+      end
+    end
+
+    class WithCastValue < Attribute # :nodoc:
+      def type_cast(value)
+        value
+      end
+
+      def changed_in_place_from?(old_value)
+        false
+      end
+    end
+
+    class Null < Attribute # :nodoc:
+      def initialize(name)
+        super(name, nil, Type::Value.new)
+      end
+
+      def value
+        nil
+      end
+
+      def with_value_from_database(value)
+        raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
+      end
+      alias_method :with_value_from_user, :with_value_from_database
+    end
+
+    class Uninitialized < Attribute # :nodoc:
+      def initialize(name, type)
+        super(name, nil, type)
+      end
+
+      def value
+        if block_given?
+          yield name
+        end
+      end
+
+      def value_for_database
+      end
+
+      def initialized?
+        false
+      end
+    end
+    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized
+  end
+end

data/lib/active_record/attribute_assignment.rb

@@ -11,6 +11,15 @@ module ActiveRecord
     # If the passed hash responds to <tt>permitted?</tt> method and the return value
     # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
     # exception is raised.
+    #
+    #   cat = Cat.new(name: "Gorby", status: "yawning")
+    #   cat.attributes # =>  { "name" => "Gorby", "status" => "yawning", "created_at" => nil, "updated_at" => nil}
+    #   cat.assign_attributes(status: "sleeping")
+    #   cat.attributes # =>  { "name" => "Gorby", "status" => "sleeping", "created_at" => nil, "updated_at" => nil }
+    #
+    # New attributes will be persisted in the database when the object is saved.
+    #
+    # Aliased to <tt>attributes=</tt>.
     def assign_attributes(new_attributes)
       if !new_attributes.respond_to?(:stringify_keys)
         raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
@@ -60,7 +69,7 @@ module ActiveRecord
     # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
     # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
     # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
-    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Fixnum and
+    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
     # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
     def assign_multiparameter_attributes(pairs)
       execute_callstack_for_multiparameter_attributes(
@@ -106,7 +115,7 @@ module ActiveRecord
     end
 
     class MultiparameterAttribute #:nodoc:
-      attr_reader :object, :name, :values, :column
+      attr_reader :object, :name, :values, :cast_type
 
       def initialize(object, name, values)
         @object = object
@@ -117,22 +126,22 @@ module ActiveRecord
       def read_value
         return if values.values.compact.empty?
 
-        @column = object.class.reflect_on_aggregation(name.to_sym) || object.column_for_attribute(name)
-        klass   = column.klass
+        @cast_type = object.type_for_attribute(name)
+        klass = cast_type.klass
 
         if klass == Time
           read_time
         elsif klass == Date
           read_date
         else
-          read_other(klass)
+          read_other
         end
       end
 
       private
 
       def instantiate_time_object(set_values)
-        if object.class.send(:create_time_zone_conversion_attribute?, name, column)
+        if object.class.send(:create_time_zone_conversion_attribute?, name, cast_type)
           Time.zone.local(*set_values)
         else
           Time.send(object.class.default_timezone, *set_values)
@@ -140,9 +149,9 @@ module ActiveRecord
       end
 
       def read_time
-        # If column is a :time (and not :date or :timestamp) there is no need to validate if
+        # If column is a :time (and not :date or :datetime) there is no need to validate if
         # there are year/month/day fields
-        if column.type == :time
+        if cast_type.type == :time
           # if the column is a time set the values to their defaults as January 1, 1970, but only if they're nil
           { 1 => 1970, 2 => 1, 3 => 1 }.each do |key,value|
             values[key] ||= value
@@ -172,13 +181,12 @@ module ActiveRecord
         end
       end
 
-      def read_other(klass)
+      def read_other
         max_position = extract_max_param
         positions    = (1..max_position)
         validate_required_parameters!(positions)
 
-        set_values = values.values_at(*positions)
-        klass.new(*set_values)
+        values.slice(*positions)
       end
 
       # Checks whether some blank date parameter exists. Note that this is different