activerecord 5.0.0 → 5.0.7.2

data/lib/active_record/relation/batches.rb

@@ -30,11 +30,11 @@ module ActiveRecord
     #   end
     #
     # ==== Options
-    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Defaults to 1000.
     # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
     # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
-    #                               the order and limit have to be ignored due to batching.
+    #   the order and limit have to be ignored due to batching.
     #
     # This is especially useful if you want multiple workers dealing with
     # the same processing queue. You can make worker 1 handle all the records
@@ -85,11 +85,11 @@ module ActiveRecord
     # To be yielded each record one by one, use #find_each instead.
     #
     # ==== Options
-    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Defaults to 1000.
     # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
     # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
-    #                               the order and limit have to be ignored due to batching.
+    #   the order and limit have to be ignored due to batching.
     #
     # This is especially useful if you want multiple workers dealing with
     # the same processing queue. You can make worker 1 handle all the records
@@ -132,9 +132,9 @@ module ActiveRecord
     # If you do not provide a block to #in_batches, it will return a
     # BatchEnumerator which is enumerable.
     #
-    #   Person.in_batches.with_index do |relation, batch_index|
+    #   Person.in_batches.each_with_index do |relation, batch_index|
     #     puts "Processing relation ##{batch_index}"
-    #     relation.each { |relation| relation.delete_all }
+    #     relation.delete_all
     #   end
     #
     # Examples of calling methods on the returned BatchEnumerator object:
@@ -144,12 +144,12 @@ module ActiveRecord
     #   Person.in_batches.each_record(&:party_all_night!)
     #
     # ==== Options
-    # * <tt>:of</tt> - Specifies the size of the batch. Default to 1000.
-    # * <tt>:load</tt> - Specifies if the relation should be loaded. Default to false.
+    # * <tt>:of</tt> - Specifies the size of the batch. Defaults to 1000.
+    # * <tt>:load</tt> - Specifies if the relation should be loaded. Defaults to false.
     # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
     # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
-    #                               the order and limit have to be ignored due to batching.
+    #   the order and limit have to be ignored due to batching.
     #
     # This is especially useful if you want to work with the
     # ActiveRecord::Relation object instead of the array of records, or if
@@ -176,7 +176,7 @@ module ActiveRecord
     #
     # NOTE: It's not possible to set the order. That is automatically set to
     # ascending on the primary key ("id ASC") to make the batch ordering
-    # consistent. Therefore the primary key must be orderable, e.g an integer
+    # consistent. Therefore the primary key must be orderable, e.g. an integer
     # or a string.
     #
     # NOTE: You can't set the limit either, that's used to control the batch

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
@@ -240,6 +238,10 @@ module ActiveRecord
 
         select_value = operation_over_aggregate_column(column, operation, distinct)
 
+        if operation == "sum" && distinct
+          select_value.distinct = true
+        end
+
         column_alias = select_value.alias
         column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
         relation.select_values = [select_value]
@@ -284,7 +286,7 @@ module ActiveRecord
           operation,
           distinct).as(aggregate_alias)
       ]
-      select_values += select_values unless having_clause.empty?
+      select_values += self.select_values unless having_clause.empty?
 
       select_values.concat group_columns.map { |aliaz, field|
         if field.respond_to?(:as)
@@ -308,8 +310,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 +346,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,8 @@ 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
+             :to_sentence, :to_formatted_s,
+             :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

@@ -17,8 +17,8 @@ module ActiveRecord
     #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
     # NOTE: The returned records may not be in the same order as the ids you
-    # provide since database rows are unordered. You'd need to provide an explicit QueryMethods#order
-    # option if you want the results are sorted.
+    # provide since database rows are unordered. You will need to provide an explicit QueryMethods#order
+    # option if you want the results to be sorted.
     #
     # ==== Find with lock
     #
@@ -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/relation.rb

@@ -347,7 +347,7 @@ module ActiveRecord
     # Please check unscoped if you want to remove all previous scopes (including
     # the default_scope) during the execution of a block.
     def scoping
-      previous, klass.current_scope = klass.current_scope, self
+      previous, klass.current_scope = klass.current_scope(true), self
       yield
     ensure
       klass.current_scope = previous
@@ -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
@@ -686,6 +689,10 @@ module ActiveRecord
       "#<#{self.class.name} [#{entries.join(', ')}]>"
     end
 
+    def empty_scope? # :nodoc:
+      @values == klass.unscoped.values
+    end
+
     protected
 
       def load_records(records)
@@ -695,8 +702,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/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/default.rb

@@ -110,7 +110,11 @@ module ActiveRecord
 
           if self.default_scope_override
             # The user has defined their own default scope method, so call that
-            evaluate_default_scope { default_scope }
+            evaluate_default_scope do
+              if scope = default_scope
+                (base_rel ||= relation).merge(scope)
+              end
+            end
           elsif default_scopes.any?
             base_rel ||= relation
             evaluate_default_scope do

data/lib/active_record/scoping/named.rb

@@ -29,13 +29,25 @@ module ActiveRecord
           end
         end
 
-        def default_scoped # :nodoc:
-          scope = build_default_scope
+        def scope_for_association(scope = relation) # :nodoc:
+          current_scope = self.current_scope
 
-          if scope
-            relation.spawn.merge!(scope)
+          if current_scope && current_scope.empty_scope?
+            scope
           else
-            relation
+            default_scoped(scope)
+          end
+        end
+
+        def default_scoped(scope = relation) # :nodoc:
+          build_default_scope(scope) || scope
+        end
+
+        def default_extensions # :nodoc:
+          if scope = current_scope || build_default_scope
+            scope.extensions
+          else
+            []
           end
         end
 
@@ -174,7 +186,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/scoping.rb

@@ -10,8 +10,8 @@ module ActiveRecord
     end
 
     module ClassMethods
-      def current_scope #:nodoc:
-        ScopeRegistry.value_for(:current_scope, self)
+      def current_scope(skip_inherited_scope = false) # :nodoc:
+        ScopeRegistry.value_for(:current_scope, self, skip_inherited_scope)
       end
 
       def current_scope=(scope) #:nodoc:
@@ -75,8 +75,9 @@ module ActiveRecord
       end
 
       # Obtains the value for a given +scope_type+ and +model+.
-      def value_for(scope_type, model)
+      def value_for(scope_type, model, skip_inherited_scope = false)
         raise_invalid_scope_type!(scope_type)
+        return @registry[scope_type][model.name] if skip_inherited_scope
         klass = model
         base = model.base_class
         while klass <= base

data/lib/active_record/serialization.rb

@@ -9,7 +9,7 @@ module ActiveRecord #:nodoc:
     end
 
     def serializable_hash(options = nil)
-      options = options.try(:clone) || {}
+      options = options.try(:dup) || {}
 
       options[:except] = Array(options[:except]).map(&:to_s)
       options[:except] |= Array(self.class.inheritance_column)

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.to_s.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

data/lib/active_record/tasks/database_tasks.rb

@@ -154,6 +154,8 @@ module ActiveRecord
       end
 
       def migrate
+        raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
         verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
         version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
         scope   = ENV['SCOPE']
@@ -213,22 +215,22 @@ module ActiveRecord
         class_for_adapter(configuration['adapter']).new(*arguments).structure_load(filename)
       end
 
-      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env) # :nodoc:
         file ||= schema_file(format)
 
+        check_schema_file(file)
+        ActiveRecord::Base.establish_connection(configuration)
+
         case format
         when :ruby
-          check_schema_file(file)
-          ActiveRecord::Base.establish_connection(configuration)
           load(file)
         when :sql
-          check_schema_file(file)
           structure_load(configuration, file)
         else
           raise ArgumentError, "unknown format #{format.inspect}"
         end
         ActiveRecord::InternalMetadata.create_table
-        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+        ActiveRecord::InternalMetadata[:environment] = environment
       end
 
       def load_schema_for(*args)
@@ -249,8 +251,8 @@ module ActiveRecord
       end
 
       def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
-        each_current_configuration(environment) { |configuration|
-          load_schema configuration, format, file
+        each_current_configuration(environment) { |configuration, configuration_environment|
+          load_schema configuration, format, file, configuration_environment
         }
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
@@ -258,7 +260,7 @@ module ActiveRecord
       def check_schema_file(filename)
         unless File.exist?(filename)
           message = %{#{filename} doesn't exist yet. Run `rails db:migrate` to create it, then try again.}
-          message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails)
+          message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails.root)
           Kernel.abort message
         end
       end
@@ -287,9 +289,10 @@ module ActiveRecord
         environments = [environment]
         environments << 'test' if environment == 'development'
 
-        configurations = ActiveRecord::Base.configurations.values_at(*environments)
-        configurations.compact.each do |configuration|
-          yield configuration unless configuration['database'].blank?
+        ActiveRecord::Base.configurations.slice(*environments).each do |configuration_environment, configuration|
+          next unless configuration["database"]
+
+          yield configuration, configuration_environment
         end
       end
 

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -16,7 +16,7 @@ module ActiveRecord
           configuration.merge('encoding' => encoding)
         establish_connection configuration
       rescue ActiveRecord::StatementInvalid => error
-        if /database .* already exists/ === error.message
+        if error.cause.is_a?(PG::DuplicateDatabase)
           raise DatabaseAlreadyExists
         else
           raise

data/lib/active_record/touch_later.rb

@@ -8,7 +8,12 @@ module ActiveRecord
     end
 
     def touch_later(*names) # :nodoc:
-      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
 
       @_defer_touch_attrs ||= timestamp_attributes_for_update_in_model
       @_defer_touch_attrs |= names

data/lib/active_record/transactions.rb

@@ -124,7 +124,7 @@ module ActiveRecord
     #     # statement will cause a PostgreSQL error, even though the unique
     #     # constraint is no longer violated:
     #     Number.create(i: 1)
-    #     # => "PGError: ERROR:  current transaction is aborted, commands
+    #     # => "PG::Error: ERROR:  current transaction is aborted, commands
     #     #     ignored until end of transaction block"
     #   end
     #

data/lib/active_record/type/internal/abstract_json.rb

@@ -17,7 +17,11 @@ module ActiveRecord
         end
 
         def serialize(value)
-          ::ActiveSupport::JSON.encode(value)
+          if value.nil?
+            nil
+          else
+            ::ActiveSupport::JSON.encode(value)
+          end
         end
 
         def accessor

data/lib/active_record/validations/uniqueness.rb

@@ -86,11 +86,10 @@ module ActiveRecord
 
       def scope_relation(record, table, relation)
         Array(options[:scope]).each do |scope_item|
-          if reflection = record.class._reflect_on_association(scope_item)
-            scope_value = record.send(reflection.foreign_key)
-            scope_item  = reflection.foreign_key
+          scope_value = if record.class._reflect_on_association(scope_item)
+            record.association(scope_item).reader
           else
-            scope_value = record._read_attribute(scope_item)
+            record._read_attribute(scope_item)
           end
           relation = relation.where(scope_item => scope_value)
         end