activerecord 5.2.8.1 → 6.0.0.beta1

data/lib/active_record/model_schema.rb

@@ -102,6 +102,21 @@ module ActiveRecord
     # If true, the default table name for a Product class will be "products". If false, it would just be "product".
     # See table_name for the full rules on table/class naming. This is true, by default.
 
+    ##
+    # :singleton-method: implicit_order_column
+    # :call-seq: implicit_order_column
+    #
+    # The name of the column records are ordered by if no explicit order clause
+    # is used during an ordered finder call. If not set the primary key is used.
+
+    ##
+    # :singleton-method: implicit_order_column=
+    # :call-seq: implicit_order_column=(column_name)
+    #
+    # Sets the column to sort records by when no explicit order clause is used
+    # during an ordered finder call. Useful when the primary key is not an
+    # auto-incrementing integer, for example when it's a UUID. Note that using
+    # a non-unique column can result in non-deterministic results.
     included do
       mattr_accessor :primary_key_prefix_type, instance_writer: false
 
@@ -110,6 +125,7 @@ module ActiveRecord
       class_attribute :schema_migrations_table_name, instance_accessor: false, default: "schema_migrations"
       class_attribute :internal_metadata_table_name, instance_accessor: false, default: "ar_internal_metadata"
       class_attribute :pluralize_table_names, instance_writer: false, default: true
+      class_attribute :implicit_order_column, instance_accessor: false
 
       self.protected_environments = ["production"]
       self.inheritance_column = "type"
@@ -218,11 +234,11 @@ module ActiveRecord
       end
 
       def full_table_name_prefix #:nodoc:
-        (parents.detect { |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+        (module_parents.detect { |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
       end
 
       def full_table_name_suffix #:nodoc:
-        (parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+        (module_parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
       end
 
       # The array of names of environments where destructive actions should be prohibited. By default,
@@ -276,7 +292,7 @@ module ActiveRecord
       end
 
       def sequence_name
-        if base_class == self
+        if base_class?
           @sequence_name ||= reset_sequence_name
         else
           (@sequence_name ||= nil) || base_class.sequence_name
@@ -388,6 +404,11 @@ module ActiveRecord
         @column_names ||= columns.map(&:name)
       end
 
+      def symbol_column_to_string(name_symbol) # :nodoc:
+        @symbol_column_to_string_name_hash ||= column_names.index_by(&:to_sym)
+        @symbol_column_to_string_name_hash[name_symbol]
+      end
+
       # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
       # and columns used for single table inheritance have been removed.
       def content_columns
@@ -477,6 +498,7 @@ module ActiveRecord
         def reload_schema_from_cache
           @arel_table = nil
           @column_names = nil
+          @symbol_column_to_string_name_hash = nil
           @attribute_types = nil
           @content_columns = nil
           @default_attributes = nil
@@ -501,19 +523,18 @@ module ActiveRecord
 
         # Computes and returns a table name according to default conventions.
         def compute_table_name
-          base = base_class
-          if self == base
+          if base_class?
             # Nested classes are prefixed with singular parent table name.
-            if parent < Base && !parent.abstract_class?
-              contained = parent.table_name
-              contained = contained.singularize if parent.pluralize_table_names
+            if module_parent < Base && !module_parent.abstract_class?
+              contained = module_parent.table_name
+              contained = contained.singularize if module_parent.pluralize_table_names
               contained += "_"
             end
 
             "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
           else
             # STI subclasses always use their superclass' table.
-            base.table_name
+            base_class.table_name
           end
         end
     end

data/lib/active_record/nested_attributes.rb

@@ -426,7 +426,7 @@ module ActiveRecord
             existing_record.assign_attributes(assignable_attributes)
             association(association_name).initialize_attributes(existing_record)
           else
-            method = "build_#{association_name}"
+            method = :"build_#{association_name}"
             if respond_to?(method)
               send(method, assignable_attributes)
             else
@@ -501,7 +501,7 @@ module ActiveRecord
 
           if attributes["id"].blank?
             unless reject_new_record?(association_name, attributes)
-              association.build(attributes.except(*UNASSIGNABLE_KEYS))
+              association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
             end
           elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
             unless call_reject_if(association_name, attributes)

data/lib/active_record/no_touching.rb

@@ -43,6 +43,13 @@ module ActiveRecord
         end
     end
 
+    # Returns +true+ if the class has +no_touching+ set, +false+ otherwise.
+    #
+    #   Project.no_touching do
+    #     Project.first.no_touching? # true
+    #     Message.first.no_touching? # false
+    #   end
+    #
     def no_touching?
       NoTouching.applied_to?(self.class)
     end

data/lib/active_record/persistence.rb

@@ -67,8 +67,7 @@ module ActiveRecord
       # how this "single-table" inheritance mapping is implemented.
       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, &block)
+        instantiate_instance_of(klass, attributes, column_types, &block)
       end
 
       # Updates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -178,7 +177,7 @@ module ActiveRecord
         end
 
         if values.empty?
-          im = arel_table.compile_insert(connection.empty_insert_statement_value)
+          im = arel_table.compile_insert(connection.empty_insert_statement_value(primary_key))
           im.into arel_table
         else
           im = arel_table.compile_insert(_substitute_values(values))
@@ -208,6 +207,13 @@ module ActiveRecord
       end
 
       private
+        # Given a class, an attributes hash, +instantiate_instance_of+ returns a
+        # new instance of the class. Accepts only keys as strings.
+        def instantiate_instance_of(klass, attributes, column_types = {}, &block)
+          attributes = klass.attributes_builder.build_from_database(attributes, column_types)
+          klass.allocate.init_with_attributes(attributes, &block)
+        end
+
         # Called by +instantiate+ to decide which class to use for a new
         # record instance.
         #
@@ -430,6 +436,7 @@ module ActiveRecord
     end
 
     alias update_attributes update
+    deprecate :update_attributes
 
     # Updates its receiver just like #update but calls #save! instead
     # of +save+, so an exception is raised if the record is invalid and saving will fail.
@@ -443,6 +450,7 @@ module ActiveRecord
     end
 
     alias update_attributes! update!
+    deprecate :update_attributes!
 
     # Equivalent to <code>update_columns(name => value)</code>.
     def update_column(name, value)
@@ -709,7 +717,6 @@ module ActiveRecord
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
     def _update_record(attribute_names = self.attribute_names)
-      attribute_names &= self.class.column_names
       attribute_names = attributes_for_update(attribute_names)
 
       if attribute_names.empty?
@@ -728,10 +735,12 @@ module ActiveRecord
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
     def _create_record(attribute_names = self.attribute_names)
-      attribute_names &= self.class.column_names
-      attributes_values = attributes_with_values_for_create(attribute_names)
+      attribute_names = attributes_for_create(attribute_names)
+
+      new_id = self.class._insert_record(
+        attributes_with_values(attribute_names)
+      )
 
-      new_id = self.class._insert_record(attributes_values)
       self.id ||= new_id if self.class.primary_key
 
       @new_record = false
@@ -752,6 +761,8 @@ module ActiveRecord
       @_association_destroy_exception = nil
     end
 
+    # The name of the method used to touch a +belongs_to+ association when the
+    # +:touch+ option is used.
     def belongs_to_touch_method
       :touch
     end

data/lib/active_record/query_cache.rb

@@ -26,15 +26,22 @@ module ActiveRecord
     end
 
     def self.run
-      ActiveRecord::Base.connection_handler.connection_pool_list.
-        reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! }
+      pools = []
+
+      ActiveRecord::Base.connection_handlers.each do |key, handler|
+        pools << handler.connection_pool_list.reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! }
+      end
+
+      pools.flatten
     end
 
     def self.complete(pools)
       pools.each { |pool| pool.disable_query_cache! }
 
-      ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
-        pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
+      ActiveRecord::Base.connection_handlers.each do |_, handler|
+        handler.connection_pool_list.each do |pool|
+          pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
+        end
       end
     end
 

data/lib/active_record/querying.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :none?, :one?, to: :all
     delegate :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!, :forty_two, :forty_two!, :third_to_last, :third_to_last!, :second_to_last, :second_to_last!, to: :all
     delegate :first_or_create, :first_or_create!, :first_or_initialize, to: :all
-    delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, to: :all
+    delegate :find_or_create_by, :find_or_create_by!, :create_or_find_by, :create_or_find_by!, :find_or_initialize_by, to: :all
     delegate :find_by, :find_by!, to: :all
     delegate :destroy_all, :delete_all, :update_all, to: :all
     delegate :find_each, :find_in_batches, :in_batches, to: :all
@@ -13,20 +13,20 @@ module ActiveRecord
              :where, :rewhere, :preload, :eager_load, :includes, :from, :lock, :readonly, :extending,
              :having, :create_with, :distinct, :references, :none, :unscope, :merge, to: :all
     delegate :count, :average, :minimum, :maximum, :sum, :calculate, to: :all
-    delegate :pluck, :ids, to: :all
+    delegate :pluck, :pick, :ids, to: :all
 
     # Executes a custom SQL query against your database and returns all the results. The results will
-    # be returned as an array with columns requested encapsulated as attributes of the model you call
-    # this method from. If you call <tt>Product.find_by_sql</tt> then the results will be returned in
+    # be returned as an array, with the requested columns encapsulated as attributes of the model you call
+    # this method from. For example, if you call <tt>Product.find_by_sql</tt>, then the results will be returned in
     # a +Product+ object with the attributes you specified in the SQL query.
     #
-    # If you call a complicated SQL query which spans multiple tables the columns specified by the
+    # If you call a complicated SQL query which spans multiple tables, the columns specified by the
     # SELECT will be attributes of the model, whether or not they are columns of the corresponding
     # table.
     #
-    # The +sql+ parameter is a full SQL query as a string. It will be called as is, there will be
-    # no database agnostic conversions performed. This should be a last resort because using, for example,
-    # MySQL specific terms will lock you to using that particular database engine or require you to
+    # The +sql+ parameter is a full SQL query as a string. It will be called as is; there will be
+    # no database agnostic conversions performed. This should be a last resort because using
+    # database-specific terms will lock you into using that particular database engine, or require you to
     # change your call if you switch engines.
     #
     #   # A simple SQL query spanning multiple tables
@@ -40,7 +40,8 @@ module ActiveRecord
     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
-      attribute_types.each_key { |k| column_types.delete k }
+      cached_columns_hash = connection.schema_cache.columns_hash(table_name)
+      cached_columns_hash.each_key { |k| column_types.delete k }
       message_bus = ActiveSupport::Notifications.instrumenter
 
       payload = {
@@ -49,13 +50,20 @@ module ActiveRecord
       }
 
       message_bus.instrument("instantiation.active_record", payload) do
-        result_set.map { |record| instantiate(record, column_types, &block) }
+        if result_set.includes_column?(inheritance_column)
+          result_set.map { |record| instantiate(record, column_types, &block) }
+        else
+          # Instantiate a homogeneous set
+          result_set.map { |record| instantiate_instance_of(self, record, column_types, &block) }
+        end
       end
     end
 
     # Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part.
     # The use of this method should be restricted to complicated SQL queries that can't be executed
-    # using the ActiveRecord::Calculations class methods. Look into those before using this.
+    # using the ActiveRecord::Calculations class methods. Look into those before using this method,
+    # as it could lock you into a specific database engine or require a code change to switch
+    # database engines.
     #
     #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
     #   # => 12

data/lib/active_record/railtie.rb

@@ -77,6 +77,10 @@ module ActiveRecord
       ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
     end
 
+    initializer "active_record.backtrace_cleaner" do
+      ActiveSupport.on_load(:active_record) { LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner }
+    end
+
     initializer "active_record.migration_error" do
       if config.active_record.delete(:migration_error) == :page_load
         config.app_middleware.insert_after ::ActionDispatch::Callbacks,
@@ -84,6 +88,31 @@ module ActiveRecord
       end
     end
 
+    initializer "Check for cache versioning support" do
+      config.after_initialize do |app|
+        ActiveSupport.on_load(:active_record) do
+          if app.config.active_record.cache_versioning && Rails.cache
+            unless Rails.cache.class.try(:supports_cache_versioning?)
+              raise <<-end_error
+
+You're using a cache store that doesn't support native cache versioning.
+Your best option is to upgrade to a newer version of #{Rails.cache.class}
+that supports cache versioning (#{Rails.cache.class}.supports_cache_versioning? #=> true).
+
+Next best, switch to a different cache store that does support cache versioning:
+https://guides.rubyonrails.org/caching_with_rails.html#cache-stores.
+
+To keep using the current cache store, you can turn off cache versioning entirely:
+
+    config.active_record.cache_versioning = false
+
+end_error
+            end
+          end
+        end
+      end
+    end
+
     initializer "active_record.check_schema_cache_dump" do
       if config.active_record.delete(:use_schema_cache_dump)
         config.after_initialize do |app|
@@ -108,6 +137,26 @@ module ActiveRecord
       end
     end
 
+    initializer "active_record.define_attribute_methods" do |app|
+      config.after_initialize do
+        ActiveSupport.on_load(:active_record) do
+          if app.config.eager_load
+            descendants.each do |model|
+              # SchemaMigration and InternalMetadata both override `table_exists?`
+              # to bypass the schema cache, so skip them to avoid the extra queries.
+              next if model._internal?
+
+              # If there's no connection yet, or the schema cache doesn't have the columns
+              # hash for the model cached, `define_attribute_methods` would trigger a query.
+              next unless model.connected? && model.connection.schema_cache.columns_hash?(model.table_name)
+
+              model.define_attribute_methods
+            end
+          end
+        end
+      end
+    end
+
     initializer "active_record.warn_on_records_fetched_greater_than" do
       if config.active_record.warn_on_records_fetched_greater_than
         ActiveSupport.on_load(:active_record) do
@@ -118,8 +167,18 @@ module ActiveRecord
 
     initializer "active_record.set_configs" do |app|
       ActiveSupport.on_load(:active_record) do
-        configs = app.config.active_record.dup
+        configs = app.config.active_record
+
+        represent_boolean_as_integer = configs.sqlite3.delete(:represent_boolean_as_integer)
+
+        unless represent_boolean_as_integer.nil?
+          ActiveSupport.on_load(:active_record_sqlite3adapter) do
+            ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer = represent_boolean_as_integer
+          end
+        end
+
         configs.delete(:sqlite3)
+
         configs.each do |k, v|
           send "#{k}=", v
         end
@@ -131,21 +190,7 @@ module ActiveRecord
     initializer "active_record.initialize_database" do
       ActiveSupport.on_load(:active_record) do
         self.configurations = Rails.application.config.database_configuration
-
-        begin
-          establish_connection
-        rescue ActiveRecord::NoDatabaseError
-          warn <<-end_warning
-Oops - You have a database configured, but it doesn't exist yet!
-
-Here's how to get started:
-
-  1. Configure your database in config/database.yml.
-  2. Run `bin/rails db:create` to create the database.
-  3. Run `bin/rails db:setup` to load your database schema.
-end_warning
-          raise
-        end
+        establish_connection
       end
     end
 
@@ -157,6 +202,13 @@ end_warning
       end
     end
 
+    initializer "active_record.collection_cache_association_loading" do
+      require "active_record/railties/collection_cache_association_loading"
+      ActiveSupport.on_load(:action_view) do
+        ActionView::PartialRenderer.prepend(ActiveRecord::Railties::CollectionCacheAssociationLoading)
+      end
+    end
+
     initializer "active_record.set_reloader_hooks" do
       ActiveSupport.on_load(:active_record) do
         ActiveSupport::Reloader.before_class_unload do
@@ -194,50 +246,9 @@ end_warning
       end
     end
 
-    initializer "active_record.check_represent_sqlite3_boolean_as_integer" do
-      config.after_initialize do
-        ActiveSupport.on_load(:active_record_sqlite3adapter) do
-          represent_boolean_as_integer = Rails.application.config.active_record.sqlite3.delete(:represent_boolean_as_integer)
-          unless represent_boolean_as_integer.nil?
-            ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer = represent_boolean_as_integer
-          end
-
-          unless ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer
-            ActiveSupport::Deprecation.warn <<-MSG
-Leaving `ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer`
-set to false is deprecated. SQLite databases have used 't' and 'f' to serialize
-boolean values and must have old data converted to 1 and 0 (its native boolean
-serialization) before setting this flag to true. Conversion can be accomplished
-by setting up a rake task which runs
-
-  ExampleModel.where("boolean_column = 't'").update_all(boolean_column: 1)
-  ExampleModel.where("boolean_column = 'f'").update_all(boolean_column: 0)
-
-for all models and all boolean columns, after which the flag must be set to
-true by adding the following to your application.rb file:
-
-  Rails.application.config.active_record.sqlite3.represent_boolean_as_integer = true
-MSG
-          end
-        end
-      end
-    end
-    
-    initializer "active_record.use_yaml_unsafe_load" do |app|
-      config.after_initialize do
-        unless app.config.active_record.use_yaml_unsafe_load.nil?
-          ActiveRecord::Base.use_yaml_unsafe_load =
-            app.config.active_record.use_yaml_unsafe_load
-        end
-      end
-    end
-
-    initializer "active_record.yaml_column_permitted_classes" do |app|
-      config.after_initialize do
-        unless app.config.active_record.yaml_column_permitted_classes.nil?
-          ActiveRecord::Base.yaml_column_permitted_classes =
-            app.config.active_record.yaml_column_permitted_classes
-        end
+    initializer "active_record.set_filter_attributes" do
+      ActiveSupport.on_load(:active_record) do
+        self.filter_attributes += Rails.application.config.filter_parameters
       end
     end
   end

data/lib/active_record/railties/collection_cache_association_loading.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Railties # :nodoc:
+    module CollectionCacheAssociationLoading #:nodoc:
+      def setup(context, options, block)
+        @relation = relation_from_options(options)
+
+        super
+      end
+
+      def relation_from_options(cached: nil, partial: nil, collection: nil, **_)
+        return unless cached
+
+        relation = partial if partial.is_a?(ActiveRecord::Relation)
+        relation ||= collection if collection.is_a?(ActiveRecord::Relation)
+
+        if relation && !relation.loaded?
+          relation.skip_preloading!
+        end
+      end
+
+      def collection_without_template
+        @relation.preload_associations(@collection) if @relation
+        super
+      end
+
+      def collection_with_template
+        @relation.preload_associations(@collection) if @relation
+        super
+      end
+    end
+  end
+end

data/lib/active_record/railties/controller_runtime.rb

@@ -8,49 +8,44 @@ module ActiveRecord
     module ControllerRuntime #:nodoc:
       extend ActiveSupport::Concern
 
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_internal :db_runtime
-
-    private
-
-      def process_action(action, *args)
-        # We also need to reset the runtime before each action
-        # because of queries in middleware or in cases we are streaming
-        # and it won't be cleaned up by the method below.
-        ActiveRecord::LogSubscriber.reset_runtime
-        super
+      module ClassMethods # :nodoc:
+        def log_process_action(payload)
+          messages, db_runtime = super, payload[:db_runtime]
+          messages << ("ActiveRecord: %.1fms" % db_runtime.to_f) if db_runtime
+          messages
+        end
       end
 
-      def cleanup_view_runtime
-        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
-          db_rt_after_render = ActiveRecord::LogSubscriber.reset_runtime
-          self.db_runtime += db_rt_after_render
-          runtime - db_rt_after_render
-        else
+      private
+        attr_internal :db_runtime
+
+        def process_action(action, *args)
+          # We also need to reset the runtime before each action
+          # because of queries in middleware or in cases we are streaming
+          # and it won't be cleaned up by the method below.
+          ActiveRecord::LogSubscriber.reset_runtime
           super
         end
-      end
 
-      def append_info_to_payload(payload)
-        super
-        if ActiveRecord::Base.connected?
-          payload[:db_runtime] = (db_runtime || 0) + ActiveRecord::LogSubscriber.reset_runtime
+        def cleanup_view_runtime
+          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
+            db_rt_after_render = ActiveRecord::LogSubscriber.reset_runtime
+            self.db_runtime += db_rt_after_render
+            runtime - db_rt_after_render
+          else
+            super
+          end
         end
-      end
 
-      module ClassMethods # :nodoc:
-        def log_process_action(payload)
-          messages, db_runtime = super, payload[:db_runtime]
-          messages << ("ActiveRecord: %.1fms" % db_runtime.to_f) if db_runtime
-          messages
+        def append_info_to_payload(payload)
+          super
+          if ActiveRecord::Base.connected?
+            payload[:db_runtime] = (db_runtime || 0) + ActiveRecord::LogSubscriber.reset_runtime
+          end
         end
-      end
     end
   end
 end