activerecord 5.0.0.beta3 → 5.0.0.beta4

data/lib/active_record/railties/databases.rake

@@ -22,7 +22,7 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Creates the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databases in the config). Without RAILS_ENV, it defaults to creating the development and test databases.'
+  desc 'Creates the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databases in the config). Without RAILS_ENV or when RAILS_ENV is development, it defaults to creating the development and test databases.'
   task :create => [:load_config] do
     ActiveRecord::Tasks::DatabaseTasks.create_current
   end
@@ -33,7 +33,7 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV, it defaults to dropping the development and test databases.'
+  desc 'Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV or when RAILS_ENV is development, it defaults to dropping the development and test databases.'
   task :drop => [:load_config, :check_protected_environments] do
     db_namespace["drop:_unsafe"].invoke
   end
@@ -256,7 +256,7 @@ db_namespace = namespace :db do
     end
 
     desc 'Loads a schema.rb file into the database'
-    task :load => [:environment, :load_config] do
+    task :load => [:environment, :load_config, :check_protected_environments] do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV['SCHEMA'])
     end
 
@@ -278,7 +278,7 @@ db_namespace = namespace :db do
       desc 'Clears a db/schema_cache.dump file.'
       task :clear => [:environment, :load_config] do
         filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.dump")
-        FileUtils.rm(filename) if File.exist?(filename)
+        rm_f filename, verbose: false
       end
     end
 
@@ -302,7 +302,7 @@ db_namespace = namespace :db do
     end
 
     desc "Recreates the databases from the structure.sql file"
-    task :load => [:environment, :load_config] do
+    task :load => [:environment, :load_config, :check_protected_environments] do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV['SCHEMA'])
     end
 

data/lib/active_record/reflection.rb

@@ -138,6 +138,10 @@ module ActiveRecord
     #       PolymorphicReflection
     #         RuntimeReflection
     class AbstractReflection # :nodoc:
+      def through_reflection?
+        false
+      end
+
       def table_name
         klass.table_name
       end
@@ -445,6 +449,10 @@ module ActiveRecord
         scope ? [[scope]] : [[]]
       end
 
+      def has_scope?
+        scope
+      end
+
       def has_inverse?
         inverse_name
       end
@@ -700,6 +708,10 @@ module ActiveRecord
         @source_reflection_name = delegate_reflection.options[:source]
       end
 
+      def through_reflection?
+        true
+      end
+
       def klass
         @klass ||= delegate_reflection.compute_class(class_name)
       end
@@ -765,7 +777,6 @@ module ActiveRecord
       # This is for clearing cache on the reflection. Useful for tests that need to compare
       # SQL queries on associations.
       def clear_association_scope_cache # :nodoc:
-        @chain = nil
         delegate_reflection.clear_association_scope_cache
         source_reflection.clear_association_scope_cache
         through_reflection.clear_association_scope_cache
@@ -812,13 +823,19 @@ module ActiveRecord
         end
       end
 
+      def has_scope?
+        scope || options[:source_type] ||
+          source_reflection.has_scope? ||
+          through_reflection.has_scope?
+      end
+
       def join_keys(association_klass)
         source_reflection.join_keys(association_klass)
       end
 
       # A through association is nested if there would be more than one join table
       def nested?
-        chain.length > 2
+        source_reflection.through_reflection? || through_reflection.through_reflection?
       end
 
       # We want to use the klass from this reflection, rather than just delegate straight to
@@ -857,7 +874,7 @@ module ActiveRecord
           example_options = options.dup
           example_options[:source] = source_reflection_names.first
           ActiveSupport::Deprecation.warn \
-            "Ambiguous source reflection for through association.  Please " \
+            "Ambiguous source reflection for through association. Please " \
             "specify a :source directive on your declaration like:\n" \
             "\n" \
             "  class #{active_record.name} < ActiveRecord::Base\n" \
@@ -995,7 +1012,7 @@ module ActiveRecord
       end
 
       def constraints
-        [source_type_info]
+        @reflection.constraints + [source_type_info]
       end
 
       def source_type_info

data/lib/active_record/relation.rb

@@ -45,8 +45,8 @@ module ActiveRecord
           k.name == primary_key
         }]
 
-        if !primary_key_value && connection.prefetch_primary_key?(klass.table_name)
-          primary_key_value = connection.next_sequence_value(klass.sequence_name)
+        if !primary_key_value && klass.prefetch_primary_key?
+          primary_key_value = klass.next_sequence_value
           values[arel_attribute(klass.primary_key)] = primary_key_value
         end
       end
@@ -94,12 +94,12 @@ module ActiveRecord
     end
 
     def substitute_values(values) # :nodoc:
-      binds = values.map do |arel_attr, value|
-        QueryAttribute.new(arel_attr.name, value, klass.type_for_attribute(arel_attr.name))
-      end
+      binds = []
+      substitutes = []
 
-      substitutes = values.map do |(arel_attr, _)|
-        [arel_attr, Arel::Nodes::BindParam.new]
+      values.each do |arel_attr, value|
+        binds.push QueryAttribute.new(arel_attr.name, value, klass.type_for_attribute(arel_attr.name))
+        substitutes.push [arel_attr, Arel::Nodes::BindParam.new]
       end
 
       [substitutes, binds]
@@ -428,7 +428,7 @@ module ActiveRecord
           id = id.id
           ActiveSupport::Deprecation.warn(<<-MSG.squish)
             You are passing an instance of ActiveRecord::Base to `update`.
-            Please pass the id of the object by calling `.id`
+            Please pass the id of the object by calling `.id`.
           MSG
         end
         object = find(id)
@@ -457,7 +457,7 @@ module ActiveRecord
       if conditions
         ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
           Passing conditions to destroy_all is deprecated and will be removed in Rails 5.1.
-          To achieve the same use where(conditions).destroy_all
+          To achieve the same use where(conditions).destroy_all.
         MESSAGE
         where(conditions).destroy_all
       else
@@ -527,7 +527,7 @@ module ActiveRecord
       if conditions
         ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
           Passing conditions to delete_all is deprecated and will be removed in Rails 5.1.
-          To achieve the same use where(conditions).delete_all
+          To achieve the same use where(conditions).delete_all.
         MESSAGE
         where(conditions).delete_all
       else

data/lib/active_record/relation/batches.rb

@@ -2,6 +2,8 @@ require "active_record/relation/batches/batch_enumerator"
 
 module ActiveRecord
   module Batches
+    ORDER_OR_LIMIT_IGNORED_MESSAGE = "Scoped order and limit are ignored, it's forced to be batch order and batch size."
+
     # Looping through a collection of records from the database
     # (using the Scoping::Named::ClassMethods.all method, for example)
     # is very inefficient since it will try to instantiate all the objects at once.
@@ -31,6 +33,9 @@ module ActiveRecord
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Default 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.
+    #
     # This is especially useful if you want multiple workers dealing with
     # the same processing queue. You can make worker 1 handle all the records
     # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
@@ -48,13 +53,13 @@ module ActiveRecord
     #
     # NOTE: You can't set the limit either, that's used to control
     # the batch sizes.
-    def find_each(start: nil, finish: nil, batch_size: 1000)
+    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
       if block_given?
-        find_in_batches(start: start, finish: finish, batch_size: batch_size) do |records|
+        find_in_batches(start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do |records|
           records.each { |record| yield record }
         end
       else
-        enum_for(:find_each, start: start, finish: finish, batch_size: batch_size) do
+        enum_for(:find_each, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do
           relation = self
           apply_limits(relation, start, finish).size
         end
@@ -83,6 +88,9 @@ module ActiveRecord
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Default 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.
+    #
     # This is especially useful if you want multiple workers dealing with
     # the same processing queue. You can make worker 1 handle all the records
     # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
@@ -100,16 +108,16 @@ module ActiveRecord
     #
     # NOTE: You can't set the limit either, that's used to control
     # the batch sizes.
-    def find_in_batches(start: nil, finish: nil, batch_size: 1000)
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
       relation = self
       unless block_given?
-        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size) do
+        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do
           total = apply_limits(relation, start, finish).size
           (total - 1).div(batch_size) + 1
         end
       end
 
-      in_batches(of: batch_size, start: start, finish: finish, load: true) do |batch|
+      in_batches(of: batch_size, start: start, finish: finish, load: true, error_on_ignore: error_on_ignore) do |batch|
         yield batch.to_a
       end
     end
@@ -140,6 +148,8 @@ module ActiveRecord
     # * <tt>:load</tt> - Specifies if the relation should be loaded. Default 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.
     #
     # This is especially useful if you want to work with the
     # ActiveRecord::Relation object instead of the array of records, or if
@@ -171,14 +181,14 @@ module ActiveRecord
     #
     # NOTE: You can't set the limit either, that's used to control the batch
     # sizes.
-    def in_batches(of: 1000, start: nil, finish: nil, load: false)
+    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil)
       relation = self
       unless block_given?
         return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
       end
 
-      if logger && (arel.orders.present? || arel.taken.present?)
-        logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+      if arel.orders.present? || arel.taken.present?
+        act_on_order_or_limit_ignored(error_on_ignore)
       end
 
       relation = relation.reorder(batch_order).limit(of)
@@ -219,5 +229,15 @@ module ActiveRecord
     def batch_order
       "#{quoted_table_name}.#{quoted_primary_key} ASC"
     end
+
+    def act_on_order_or_limit_ignored(error_on_ignore)
+      raise_error = (error_on_ignore.nil? ? self.klass.error_on_ignored_order_or_limit : error_on_ignore)
+
+      if raise_error
+        raise ArgumentError.new(ORDER_OR_LIMIT_IGNORED_MESSAGE)
+      elsif logger
+        logger.warn(ORDER_OR_LIMIT_IGNORED_MESSAGE)
+      end
+    end
   end
 end

data/lib/active_record/relation/delegation.rb

@@ -1,4 +1,3 @@
-require 'set'
 require 'active_support/concern'
 
 module ActiveRecord

data/lib/active_record/relation/finder_methods.rb

@@ -42,10 +42,10 @@ module ActiveRecord
     #   Person.find_by(name: 'Spartacus', rating: 4)
     #   # returns the first item or nil.
     #
-    #   Person.where(name: 'Spartacus', rating: 4).first_or_initialize
+    #   Person.find_or_initialize_by(name: 'Spartacus', rating: 4)
     #   # returns the first item or returns a new instance (requires you call .save to persist against the database).
     #
-    #   Person.where(name: 'Spartacus', rating: 4).first_or_create
+    #   Person.find_or_create_by(name: 'Spartacus', rating: 4)
     #   # returns the first item or creates it and returns it.
     #
     # ==== Alternatives for #find
@@ -255,13 +255,13 @@ module ActiveRecord
     #   Person.offset(3).third_to_last # returns the third-to-last object from OFFSET 3
     #   Person.where(["user_name = :u", { u: user_name }]).third_to_last
     def third_to_last
-      find_nth(-3)
+      find_nth_from_last 3
     end
 
     # Same as #third_to_last but raises ActiveRecord::RecordNotFound if no record
     # is found.
     def third_to_last!
-      find_nth!(-3)
+      find_nth_from_last 3 or raise RecordNotFound.new("Couldn't find #{@klass.name} with [#{arel.where_sql(@klass.arel_engine)}]")
     end
 
     # Find the second-to-last record.
@@ -271,13 +271,13 @@ module ActiveRecord
     #   Person.offset(3).second_to_last # returns the second-to-last object from OFFSET 3
     #   Person.where(["user_name = :u", { u: user_name }]).second_to_last
     def second_to_last
-      find_nth(-2)
+      find_nth_from_last 2
     end
 
     # Same as #second_to_last but raises ActiveRecord::RecordNotFound if no record
     # is found.
     def second_to_last!
-      find_nth!(-2)
+      find_nth_from_last 2 or raise RecordNotFound.new("Couldn't find #{@klass.name} with [#{arel.where_sql(@klass.arel_engine)}]")
     end
 
     # Returns true if a record exists in the table that matches the +id+ or
@@ -312,7 +312,7 @@ module ActiveRecord
         conditions = conditions.id
         ActiveSupport::Deprecation.warn(<<-MSG.squish)
           You are passing an instance of ActiveRecord::Base to `exists?`.
-          Please pass the id of the object by calling `.id`
+          Please pass the id of the object by calling `.id`.
         MSG
       end
 
@@ -467,7 +467,7 @@ module ActiveRecord
         id = id.id
         ActiveSupport::Deprecation.warn(<<-MSG.squish)
           You are passing an instance of ActiveRecord::Base to `find`.
-          Please pass the id of the object by calling `.id`
+          Please pass the id of the object by calling `.id`.
         MSG
       end
 
@@ -561,6 +561,25 @@ module ActiveRecord
       relation.limit(limit).to_a
     end
 
+    def find_nth_from_last(index)
+      if loaded?
+        @records[-index]
+      else
+        relation = if order_values.empty? && primary_key
+                     order(arel_attribute(primary_key).asc)
+                   else
+                     self
+                   end
+
+        relation.to_a[-index]
+        # TODO: can be made more performant on large result sets by
+        # for instance, last(index)[-index] (which would require
+        # refactoring the last(n) finder method to make test suite pass),
+        # or by using a combination of reverse_order, limit, and offset,
+        # e.g., reverse_order.offset(index-1).first
+      end
+    end
+    
     private
 
     def find_nth_with_limit_and_offset(index, limit, offset:) # :nodoc:

data/lib/active_record/relation/predicate_builder.rb

@@ -136,9 +136,11 @@ module ActiveRecord
     end
 
     def convert_dot_notation_to_hash(attributes)
-      dot_notation = attributes.keys.select { |s| s.include?(".".freeze) }
+      dot_notation = attributes.select do |k, v|
+        k.include?(".".freeze) && !v.is_a?(Hash)
+      end
 
-      dot_notation.each do |key|
+      dot_notation.each_key do |key|
         table_name, column_name = key.split(".".freeze)
         value = attributes.delete(key)
         attributes[table_name] ||= {}

data/lib/active_record/relation/where_clause.rb

@@ -158,8 +158,9 @@ module ActiveRecord
         end
       end
 
+      ARRAY_WITH_EMPTY_STRING = ['']
       def non_empty_predicates
-        predicates - ['']
+        predicates - ARRAY_WITH_EMPTY_STRING
       end
 
       def wrap_sql_literal(node)

data/lib/active_record/schema_dumper.rb

@@ -104,10 +104,7 @@ HEADER
       end
 
       def table(table, stream)
-        columns = @connection.columns(table).map do |column|
-          column.instance_variable_set(:@table_name, table)
-          column
-        end
+        columns = @connection.columns(table)
         begin
           tbl = StringIO.new
 
@@ -126,7 +123,7 @@ HEADER
             tbl.print ", primary_key: #{pk.inspect}" unless pk == 'id'
             pkcol = columns.detect { |c| c.name == pk }
             pkcolspec = @connection.column_spec_for_primary_key(pkcol)
-            if pkcolspec
+            if pkcolspec.present?
               pkcolspec.each do |key, value|
                 tbl.print ", #{key}: #{value}"
               end
@@ -141,6 +138,10 @@ HEADER
           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}"
+          end
+
           tbl.puts " do |t|"
 
           # then dump all non-primary key columns
@@ -178,11 +179,11 @@ HEADER
             tbl.puts
           end
 
+          indexes_in_create(table, tbl)
+
           tbl.puts "  end"
           tbl.puts
 
-          indexes(table, tbl)
-
           tbl.rewind
           stream.print tbl.read
         rescue => e
@@ -194,26 +195,12 @@ HEADER
         stream
       end
 
+      # Keep it for indexing materialized views
       def indexes(table, stream)
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
-            statement_parts = [
-              "add_index #{remove_prefix_and_suffix(index.table).inspect}",
-              index.columns.inspect,
-              "name: #{index.name.inspect}",
-            ]
-            statement_parts << 'unique: true' if index.unique
-
-            index_lengths = (index.lengths || []).compact
-            statement_parts << "length: #{Hash[index.columns.zip(index.lengths)].inspect}" if index_lengths.any?
-
-            index_orders = index.orders || {}
-            statement_parts << "order: #{index.orders.inspect}" if index_orders.any?
-            statement_parts << "where: #{index.where.inspect}" if index.where
-            statement_parts << "using: #{index.using.inspect}" if index.using
-            statement_parts << "type: #{index.type.inspect}" if index.type
-
-            "  #{statement_parts.join(', ')}"
+            table_name = remove_prefix_and_suffix(index.table).inspect
+            "  add_index #{([table_name]+index_parts(index)).join(', ')}"
           end
 
           stream.puts add_index_statements.sort.join("\n")
@@ -221,6 +208,34 @@ HEADER
         end
       end
 
+      def indexes_in_create(table, stream)
+        if (indexes = @connection.indexes(table)).any?
+          index_statements = indexes.map do |index|
+            "    t.index #{index_parts(index).join(', ')}"
+          end
+          stream.puts index_statements.sort.join("\n")
+        end
+      end
+
+      def index_parts(index)
+        index_parts = [
+          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 << "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
+        index_parts << "comment: #{index.comment.inspect}" if index.comment
+        index_parts
+      end
+
       def foreign_keys(table, stream)
         if (foreign_keys = @connection.foreign_keys(table)).any?
           add_foreign_key_statements = foreign_keys.map do |foreign_key|