activerecord 5.0.0.1 → 5.0.1.rc1

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
@@ -252,7 +252,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
@@ -479,7 +480,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

data/lib/active_record/query_cache.rb

@@ -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/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)
+      end
+
       def active_record_primary_key
         @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
       end

data/lib/active_record/relation.rb

@@ -372,6 +372,9 @@ module ActiveRecord
     #
     #   # Update all books that match conditions, but limit it to 5 ordered by date
     #   Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(author: 'David')
+    #
+    #   # Update all invoices and set the number column to its id value.
+    #   Invoice.update_all('number = id')
     def update_all(updates)
       raise ArgumentError, "Empty list of attributes to change" if updates.blank?
 
@@ -576,8 +579,8 @@ module ActiveRecord
     # return value is the relation itself, not the records.
     #
     #   Post.where(published: true).load # => #<ActiveRecord::Relation>
-    def load
-      exec_queries unless loaded?
+    def load(&block)
+      exec_queries(&block) unless loaded?
 
       self
     end
@@ -695,8 +698,8 @@ module ActiveRecord
 
     private
 
-    def exec_queries
-      @records = eager_loading? ? find_with_associations.freeze : @klass.find_by_sql(arel, bound_attributes).freeze
+    def exec_queries(&block)
+      @records = eager_loading? ? find_with_associations.freeze : @klass.find_by_sql(arel, bound_attributes, &block).freeze
 
       preload = preload_values
       preload +=  includes_values unless eager_loading?

data/lib/active_record/relation/calculations.rb

@@ -113,7 +113,10 @@ module ActiveRecord
       end
 
       if has_include?(column_name)
-        construct_relation_for_association_calculations.calculate(operation, column_name)
+        relation = construct_relation_for_association_calculations
+        relation = relation.distinct if operation.to_s.downcase == "count"
+
+        relation.calculate(operation, column_name)
       else
         perform_calculation(operation, column_name)
       end
@@ -156,7 +159,7 @@ module ActiveRecord
     #
     def pluck(*column_names)
       if loaded? && (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
-        return @records.pluck(*column_names)
+        return records.pluck(*column_names)
       end
 
       if has_include?(column_names.first)
@@ -194,11 +197,6 @@ module ActiveRecord
 
       if operation == "count"
         column_name ||= select_for_count
-
-        unless arel.ast.grep(Arel::Nodes::OuterJoin).empty?
-          distinct = true
-        end
-
         column_name = primary_key if column_name == :all && distinct
         distinct = nil if column_name =~ /\s*DISTINCT[\s(]+/i
       end
@@ -308,8 +306,10 @@ module ActiveRecord
 
       Hash[calculated_data.map do |row|
         key = group_columns.map { |aliaz, col_name|
-          column = calculated_data.column_types.fetch(aliaz) do
-            type_for(col_name)
+          column = type_for(col_name) do
+            calculated_data.column_types.fetch(aliaz) do
+              Type::Value.new
+            end
           end
           type_cast_calculated_value(row[aliaz], column)
         }
@@ -342,9 +342,9 @@ module ActiveRecord
       @klass.connection.table_alias_for(table_name)
     end
 
-    def type_for(field)
+    def type_for(field, &block)
       field_name = field.respond_to?(:name) ? field.name.to_s : field.to_s.split('.').last
-      @klass.type_for_attribute(field_name)
+      @klass.type_for_attribute(field_name, &block)
     end
 
     def type_cast_calculated_value(value, type, operation = nil)

data/lib/active_record/relation/delegation.rb

@@ -37,7 +37,7 @@ module ActiveRecord
 
     delegate :to_xml, :encode_with, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join,
              :[], :&, :|, :+, :-, :sample, :reverse, :compact, :in_groups, :in_groups_of,
-             :shuffle, :split, to: :records
+             :shuffle, :split, :index, to: :records
 
     delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,
              :connection, :columns_hash, :to => :klass

data/lib/active_record/relation/finder_methods.rb

@@ -343,18 +343,20 @@ module ActiveRecord
     # of results obtained should be provided in the +result_size+ argument and
     # the expected number of results should be provided in the +expected_size+
     # argument.
-    def raise_record_not_found_exception!(ids, result_size, expected_size) #:nodoc:
+    def raise_record_not_found_exception!(ids, result_size, expected_size, key = primary_key) #:nodoc:
       conditions = arel.where_sql(@klass.arel_engine)
       conditions = " [#{conditions}]" if conditions
+      name = @klass.name
 
       if Array(ids).size == 1
-        error = "Couldn't find #{@klass.name} with '#{primary_key}'=#{ids}#{conditions}"
+        error = "Couldn't find #{name} with '#{key}'=#{ids}#{conditions}"
+        raise RecordNotFound.new(error, name, key, ids)
       else
-        error = "Couldn't find all #{@klass.name.pluralize} with '#{primary_key}': "
+        error = "Couldn't find all #{name.pluralize} with '#{key}': "
         error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})"
-      end
 
-      raise RecordNotFound, error
+        raise RecordNotFound, error
+      end
     end
 
     private
@@ -520,7 +522,7 @@ module ActiveRecord
 
     def find_take
       if loaded?
-        @records.first
+        records.first
       else
         @take ||= limit(1).records.first
       end
@@ -537,7 +539,7 @@ module ActiveRecord
         MSG
       end
       if loaded?
-        @records[index]
+        records[index]
       else
         offset ||= offset_index
         @offsets[offset + index] ||= find_nth_with_limit_and_offset(index, 1, offset: offset).first
@@ -563,7 +565,7 @@ module ActiveRecord
 
     def find_nth_from_last(index)
       if loaded?
-        @records[-index]
+        records[-index]
       else
         relation = if order_values.empty? && primary_key
                      order(arel_attribute(primary_key).asc)
@@ -584,7 +586,7 @@ module ActiveRecord
 
     def find_nth_with_limit_and_offset(index, limit, offset:) # :nodoc:
       if loaded?
-        @records[index, limit]
+        records[index, limit]
       else
         index += offset
         find_nth_with_limit(index, limit)

data/lib/active_record/relation/query_methods.rb

@@ -1141,9 +1141,9 @@ module ActiveRecord
     end
 
     def does_not_support_reverse?(order)
-      #uses sql function with multiple arguments
-      order =~ /\([^()]*,[^()]*\)/ ||
-        # uses "nulls first" like construction
+      # Uses SQL function with multiple arguments.
+      (order.include?(',') && order.split(',').find { |section| section.count('(') != section.count(')')}) ||
+        # Uses "nulls first" like construction.
         order =~ /nulls (first|last)\Z/i
     end
 

data/lib/active_record/result.rb

@@ -75,8 +75,14 @@ module ActiveRecord
       hash_rows[idx]
     end
 
+    def first
+      return nil if @rows.empty?
+      Hash[@columns.zip(@rows.first)]
+    end
+
     def last
-      hash_rows.last
+      return nil if @rows.empty?
+      Hash[@columns.zip(@rows.last)]
     end
 
     def cast_values(type_overrides = {}) # :nodoc:

data/lib/active_record/sanitization.rb

@@ -116,7 +116,17 @@ module ActiveRecord
       def sanitize_sql_hash_for_assignment(attrs, table)
         c = connection
         attrs.map do |attr, value|
-          value = type_for_attribute(attr.to_s).serialize(value)
+          if value.is_a?(Base)
+            require "active_support/core_ext/string/filters"
+            ActiveSupport::Deprecation.warn(<<-WARNING.squish)
+              Passing `ActiveRecord::Base` objects to
+              `sanitize_sql_hash_for_assignment` (or methods which call it,
+              such as `update_all`) is deprecated. Please pass the id directly,
+              instead.
+            WARNING
+          else
+            value = type_for_attribute(attr.to_s).serialize(value)
+          end
           "#{c.quote_table_name_for_assignment(table, attr)} = #{c.quote(value)}"
         end.join(', ')
       end

data/lib/active_record/schema_dumper.rb

@@ -105,12 +105,7 @@ HEADER
           tbl = StringIO.new
 
           # first dump primary key column
-          if @connection.respond_to?(:primary_keys)
-            pk = @connection.primary_keys(table)
-            pk = pk.first unless pk.size > 1
-          else
-            pk = @connection.primary_key(table)
-          end
+          pk = @connection.primary_key(table)
 
           tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
 
@@ -132,10 +127,8 @@ HEADER
           tbl.print ", force: :cascade"
 
           table_options = @connection.table_options(table)
-          tbl.print ", options: #{table_options.inspect}" unless table_options.blank?
-
-          if comment = @connection.table_comment(table).presence
-            tbl.print ", comment: #{comment.inspect}"
+          if table_options.present?
+            tbl.print ", #{format_options(table_options)}"
           end
 
           tbl.puts " do |t|"
@@ -218,13 +211,9 @@ HEADER
           index.columns.inspect,
           "name: #{index.name.inspect}",
         ]
-        index_parts << 'unique: true' if index.unique
-
-        index_lengths = (index.lengths || []).compact
-        index_parts << "length: #{Hash[index.columns.zip(index.lengths)].inspect}" if index_lengths.any?
-
-        index_orders = index.orders || {}
-        index_parts << "order: #{index.orders.inspect}" if index_orders.any?
+        index_parts << "unique: true" if index.unique
+        index_parts << "length: { #{format_options(index.lengths)} }" if index.lengths.present?
+        index_parts << "order: { #{format_options(index.orders)} }" if index.orders.present?
         index_parts << "where: #{index.where.inspect}" if index.where
         index_parts << "using: #{index.using.inspect}" if index.using
         index_parts << "type: #{index.type.inspect}" if index.type
@@ -262,6 +251,10 @@ HEADER
         end
       end
 
+      def format_options(options)
+        options.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+      end
+
       def remove_prefix_and_suffix(table)
         table.gsub(/^(#{@options[:table_name_prefix]})(.+)(#{@options[:table_name_suffix]})$/,  "\\2")
       end

data/lib/active_record/scoping/named.rb

@@ -174,7 +174,7 @@ module ActiveRecord
       protected
 
         def valid_scope_name?(name)
-          if respond_to?(name, true)
+          if respond_to?(name, true) && logger
             logger.warn "Creating scope :#{name}. " \
                         "Overwriting existing method #{self.name}.#{name}."
           end

data/lib/active_record/statement_cache.rb

@@ -101,12 +101,12 @@ module ActiveRecord
       @bind_map      = bind_map
     end
 
-    def execute(params, klass, connection)
+    def execute(params, klass, connection, &block)
       bind_values = bind_map.bind params
 
       sql = query_builder.sql_for bind_values, connection
 
-      klass.find_by_sql(sql, bind_values, preparable: true)
+      klass.find_by_sql(sql, bind_values, preparable: true, &block)
     end
     alias :call :execute
   end

data/lib/active_record/table_metadata.rb

@@ -42,10 +42,11 @@ module ActiveRecord
     end
 
     def associated_table(table_name)
-      return self if table_name == arel_table.name
+      association = klass._reflect_on_association(table_name) || klass._reflect_on_association(table_name.singularize)
 
-      association = klass._reflect_on_association(table_name)
-      if association && !association.polymorphic?
+      if !association && table_name == arel_table.name
+        return self
+      elsif association && !association.polymorphic?
         association_klass = association.klass
         arel_table = association_klass.arel_table.alias(table_name)
       else