activerecord 4.2.11.1 → 6.0.3

data/lib/active_record/counter_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record Counter Cache
   module CounterCache
@@ -12,13 +14,21 @@ module ActiveRecord
       #
       # * +id+ - The id of the object you wish to reset a counter on.
       # * +counters+ - One or more association counters to reset. Association name or counter name can be given.
+      # * <tt>:touch</tt> - Touch timestamp columns when updating.
+      #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
+      #   touch that column or an array of symbols to touch just those ones.
       #
       # ==== Examples
       #
-      #   # For Post with id #1 records reset the comments_count
+      #   # For the Post with id #1, reset the comments_count
       #   Post.reset_counters(1, :comments)
-      def reset_counters(id, *counters)
+      #
+      #   # Like above, but also touch the +updated_at+ and/or +updated_on+
+      #   # attributes.
+      #   Post.reset_counters(1, :comments, touch: true)
+      def reset_counters(id, *counters, touch: nil)
         object = find(id)
+
         counters.each do |counter_association|
           has_many_association = _reflect_on_association(counter_association)
           unless has_many_association
@@ -26,7 +36,7 @@ module ActiveRecord
             has_many_association = has_many.find { |association| association.counter_cache_column && association.counter_cache_column.to_sym == counter_association.to_sym }
             counter_association = has_many_association.plural_name if has_many_association
           end
-          raise ArgumentError, "'#{self.name}' has no association called '#{counter_association}'" unless has_many_association
+          raise ArgumentError, "'#{name}' has no association called '#{counter_association}'" unless has_many_association
 
           if has_many_association.is_a? ActiveRecord::Reflection::ThroughReflection
             has_many_association = has_many_association.through_reflection
@@ -37,25 +47,36 @@ module ActiveRecord
           reflection   = child_class._reflections.values.find { |e| e.belongs_to? && e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
           counter_name = reflection.counter_cache_column
 
-          stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
-            arel_table[counter_name] => object.send(counter_association).count(:all)
-          }, primary_key)
-          connection.update stmt
+          updates = { counter_name => object.send(counter_association).count(:all) }
+
+          if touch
+            names = touch if touch != true
+            names = Array.wrap(names)
+            options = names.extract_options!
+            touch_updates = touch_attributes_with_time(*names, **options)
+            updates.merge!(touch_updates)
+          end
+
+          unscoped.where(primary_key => object.id).update_all(updates)
         end
-        return true
+
+        true
       end
 
       # A generic "counter updater" implementation, intended primarily to be
-      # used by increment_counter and decrement_counter, but which may also
+      # used by #increment_counter and #decrement_counter, but which may also
       # be useful on its own. It simply does a direct SQL update for the record
       # with the given ID, altering the given hash of counters by the amount
       # given by the corresponding value:
       #
       # ==== Parameters
       #
-      # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
+      # * +id+ - The id of the object you wish to update a counter on or an array of ids.
       # * +counters+ - A Hash containing the names of the fields
       #   to update as keys and the amount to update the field by as values.
+      # * <tt>:touch</tt> option - Touch timestamp columns when updating.
+      #   If attribute names are passed, they are updated along with updated_at/on
+      #   attributes.
       #
       # ==== Examples
       #
@@ -74,75 +95,78 @@ module ActiveRecord
       #   # UPDATE posts
       #   #    SET comment_count = COALESCE(comment_count, 0) + 1
       #   #  WHERE id IN (10, 15)
+      #
+      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
+      #   # and update the updated_at value for each counter.
+      #   Post.update_counters [10, 15], comment_count: 1, touch: true
+      #   # Executes the following SQL:
+      #   # UPDATE posts
+      #   #    SET comment_count = COALESCE(comment_count, 0) + 1,
+      #   #    `updated_at` = '2016-10-13T09:59:23-05:00'
+      #   #  WHERE id IN (10, 15)
       def update_counters(id, counters)
-        updates = counters.map do |counter_name, value|
-          operator = value < 0 ? '-' : '+'
-          quoted_column = connection.quote_column_name(counter_name)
-          "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
-        end
-
-        unscoped.where(primary_key => id).update_all updates.join(', ')
+        unscoped.where!(primary_key => id).update_counters(counters)
       end
 
       # Increment a numeric field by one, via a direct SQL update.
       #
       # This method is used primarily for maintaining counter_cache columns that are
-      # used to store aggregate values. For example, a DiscussionBoard may cache
+      # used to store aggregate values. For example, a +DiscussionBoard+ may cache
       # posts_count and comments_count to avoid running an SQL query to calculate the
       # number of posts and comments there are, each time it is displayed.
       #
       # ==== Parameters
       #
       # * +counter_name+ - The name of the field that should be incremented.
-      # * +id+ - The id of the object that should be incremented or an Array of ids.
+      # * +id+ - The id of the object that should be incremented or an array of ids.
+      # * <tt>:touch</tt> - Touch timestamp columns when updating.
+      #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
+      #   touch that column or an array of symbols to touch just those ones.
       #
       # ==== Examples
       #
-      #   # Increment the post_count column for the record with an id of 5
-      #   DiscussionBoard.increment_counter(:post_count, 5)
-      def increment_counter(counter_name, id)
-        update_counters(id, counter_name => 1)
+      #   # Increment the posts_count column for the record with an id of 5
+      #   DiscussionBoard.increment_counter(:posts_count, 5)
+      #
+      #   # Increment the posts_count column for the record with an id of 5
+      #   # and update the updated_at value.
+      #   DiscussionBoard.increment_counter(:posts_count, 5, touch: true)
+      def increment_counter(counter_name, id, touch: nil)
+        update_counters(id, counter_name => 1, touch: touch)
       end
 
       # Decrement a numeric field by one, via a direct SQL update.
       #
-      # This works the same as increment_counter but reduces the column value by
+      # This works the same as #increment_counter but reduces the column value by
       # 1 instead of increasing it.
       #
       # ==== Parameters
       #
       # * +counter_name+ - The name of the field that should be decremented.
-      # * +id+ - The id of the object that should be decremented or an Array of ids.
+      # * +id+ - The id of the object that should be decremented or an array of ids.
+      # * <tt>:touch</tt> - Touch timestamp columns when updating.
+      #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
+      #   touch that column or an array of symbols to touch just those ones.
       #
       # ==== Examples
       #
-      #   # Decrement the post_count column for the record with an id of 5
-      #   DiscussionBoard.decrement_counter(:post_count, 5)
-      def decrement_counter(counter_name, id)
-        update_counters(id, counter_name => -1)
+      #   # Decrement the posts_count column for the record with an id of 5
+      #   DiscussionBoard.decrement_counter(:posts_count, 5)
+      #
+      #   # Decrement the posts_count column for the record with an id of 5
+      #   # and update the updated_at value.
+      #   DiscussionBoard.decrement_counter(:posts_count, 5, touch: true)
+      def decrement_counter(counter_name, id, touch: nil)
+        update_counters(id, counter_name => -1, touch: touch)
       end
     end
 
-    protected
-
-      def actually_destroyed?
-        @_actually_destroyed
-      end
-
-      def clear_destroy_state
-        @_actually_destroyed = nil
-      end
-
     private
-
-      def _create_record(*)
+      def _create_record(attribute_names = self.attribute_names)
         id = super
 
         each_counter_cached_associations do |association|
-          if send(association.reflection.name)
-            association.increment_counters
-            @_after_create_counter_called = true
-          end
+          association.increment_counters
         end
 
         id
@@ -155,9 +179,7 @@ module ActiveRecord
           each_counter_cached_associations do |association|
             foreign_key = association.reflection.foreign_key.to_sym
             unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
-              if send(association.reflection.name)
-                association.decrement_counters
-              end
+              association.decrement_counters
             end
           end
         end
@@ -170,6 +192,5 @@ module ActiveRecord
           yield association(name.to_sym) if reflection.belongs_to? && reflection.counter_cache_column
         end
       end
-
   end
 end

data/lib/active_record/database_configurations/database_config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class DatabaseConfigurations
+    # ActiveRecord::Base.configurations will return either a HashConfig or
+    # UrlConfig respectively. It will never return a DatabaseConfig object,
+    # as this is the parent class for the types of database configuration objects.
+    class DatabaseConfig # :nodoc:
+      attr_reader :env_name, :spec_name
+
+      def initialize(env_name, spec_name)
+        @env_name = env_name
+        @spec_name = spec_name
+      end
+
+      def replica?
+        raise NotImplementedError
+      end
+
+      def migrations_paths
+        raise NotImplementedError
+      end
+
+      def url_config?
+        false
+      end
+
+      def to_legacy_hash
+        { env_name => config }
+      end
+
+      def for_current_env?
+        env_name == ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+      end
+    end
+  end
+end

data/lib/active_record/database_configurations/hash_config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class DatabaseConfigurations
+    # A HashConfig object is created for each database configuration entry that
+    # is created from a hash.
+    #
+    # A hash config:
+    #
+    #   { "development" => { "database" => "db_name" } }
+    #
+    # Becomes:
+    #
+    #   #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10
+    #     @env_name="development", @spec_name="primary", @config={"database"=>"db_name"}>
+    #
+    # ==== Options
+    #
+    # * <tt>:env_name</tt> - The Rails environment, i.e. "development".
+    # * <tt>:spec_name</tt> - The specification name. In a standard two-tier
+    #   database configuration this will default to "primary". In a multiple
+    #   database three-tier database configuration this corresponds to the name
+    #   used in the second tier, for example "primary_readonly".
+    # * <tt>:config</tt> - The config hash. This is the hash that contains the
+    #   database adapter, name, and other important information for database
+    #   connections.
+    class HashConfig < DatabaseConfig
+      attr_reader :config
+
+      def initialize(env_name, spec_name, config)
+        super(env_name, spec_name)
+        @config = config
+      end
+
+      # Determines whether a database configuration is for a replica / readonly
+      # connection. If the +replica+ key is present in the config, +replica?+ will
+      # return +true+.
+      def replica?
+        config["replica"]
+      end
+
+      # The migrations paths for a database configuration. If the
+      # +migrations_paths+ key is present in the config, +migrations_paths+
+      # will return its value.
+      def migrations_paths
+        config["migrations_paths"]
+      end
+    end
+  end
+end

data/lib/active_record/database_configurations/url_config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class DatabaseConfigurations
+    # A UrlConfig object is created for each database configuration
+    # entry that is created from a URL. This can either be a URL string
+    # or a hash with a URL in place of the config hash.
+    #
+    # A URL config:
+    #
+    #   postgres://localhost/foo
+    #
+    # Becomes:
+    #
+    #   #<ActiveRecord::DatabaseConfigurations::UrlConfig:0x00007fdc3238f340
+    #     @env_name="default_env", @spec_name="primary",
+    #     @config={"adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost"},
+    #     @url="postgres://localhost/foo">
+    #
+    # ==== Options
+    #
+    # * <tt>:env_name</tt> - The Rails environment, ie "development".
+    # * <tt>:spec_name</tt> - The specification name. In a standard two-tier
+    #   database configuration this will default to "primary". In a multiple
+    #   database three-tier database configuration this corresponds to the name
+    #   used in the second tier, for example "primary_readonly".
+    # * <tt>:url</tt> - The database URL.
+    # * <tt>:config</tt> - The config hash. This is the hash that contains the
+    #   database adapter, name, and other important information for database
+    #   connections.
+    class UrlConfig < DatabaseConfig
+      attr_reader :url, :config
+
+      def initialize(env_name, spec_name, url, config = {})
+        super(env_name, spec_name)
+        @config = build_config(config, url)
+        @url = url
+      end
+
+      def url_config? # :nodoc:
+        true
+      end
+
+      # Determines whether a database configuration is for a replica / readonly
+      # connection. If the +replica+ key is present in the config, +replica?+ will
+      # return +true+.
+      def replica?
+        config["replica"]
+      end
+
+      # The migrations paths for a database configuration. If the
+      # +migrations_paths+ key is present in the config, +migrations_paths+
+      # will return its value.
+      def migrations_paths
+        config["migrations_paths"]
+      end
+
+      private
+        def build_url_hash(url)
+          if url.nil? || /^jdbc:/.match?(url)
+            { "url" => url }
+          else
+            ActiveRecord::ConnectionAdapters::ConnectionSpecification::ConnectionUrlResolver.new(url).to_hash
+          end
+        end
+
+        def build_config(original_config, url)
+          hash = build_url_hash(url)
+
+          if original_config[env_name]
+            original_config[env_name].merge(hash)
+          else
+            original_config.merge(hash)
+          end
+        end
+    end
+  end
+end

data/lib/active_record/database_configurations.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "active_record/database_configurations/database_config"
+require "active_record/database_configurations/hash_config"
+require "active_record/database_configurations/url_config"
+
+module ActiveRecord
+  # ActiveRecord::DatabaseConfigurations returns an array of DatabaseConfig
+  # objects (either a HashConfig or UrlConfig) that are constructed from the
+  # application's database configuration hash or URL string.
+  class DatabaseConfigurations
+    class InvalidConfigurationError < StandardError; end
+
+    attr_reader :configurations
+    delegate :any?, to: :configurations
+
+    def initialize(configurations = {})
+      @configurations = build_configs(configurations)
+    end
+
+    # Collects the configs for the environment and optionally the specification
+    # name passed in. To include replica configurations pass <tt>include_replicas: true</tt>.
+    #
+    # If a spec name is provided a single DatabaseConfig object will be
+    # returned, otherwise an array of DatabaseConfig objects will be
+    # returned that corresponds with the environment and type requested.
+    #
+    # ==== Options
+    #
+    # * <tt>env_name:</tt> The environment name. Defaults to +nil+ which will collect
+    #   configs for all environments.
+    # * <tt>spec_name:</tt> The specification name (i.e. primary, animals, etc.). Defaults
+    #   to +nil+.
+    # * <tt>include_replicas:</tt> Determines whether to include replicas in
+    #   the returned list. Most of the time we're only iterating over the write
+    #   connection (i.e. migrations don't need to run for the write and read connection).
+    #   Defaults to +false+.
+    def configs_for(env_name: nil, spec_name: nil, include_replicas: false)
+      configs = env_with_configs(env_name)
+
+      unless include_replicas
+        configs = configs.select do |db_config|
+          !db_config.replica?
+        end
+      end
+
+      if spec_name
+        configs.find do |db_config|
+          db_config.spec_name == spec_name
+        end
+      else
+        configs
+      end
+    end
+
+    # Returns the config hash that corresponds with the environment
+    #
+    # If the application has multiple databases +default_hash+ will
+    # return the first config hash for the environment.
+    #
+    #   { database: "my_db", adapter: "mysql2" }
+    def default_hash(env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_s)
+      default = find_db_config(env)
+      default.config if default
+    end
+    alias :[] :default_hash
+
+    # Returns a single DatabaseConfig object based on the requested environment.
+    #
+    # If the application has multiple databases +find_db_config+ will return
+    # the first DatabaseConfig for the environment.
+    def find_db_config(env)
+      configurations.find do |db_config|
+        db_config.env_name == env.to_s ||
+          (db_config.for_current_env? && db_config.spec_name == env.to_s)
+      end
+    end
+
+    # Returns the DatabaseConfigurations object as a Hash.
+    def to_h
+      configs = configurations.reverse.inject({}) do |memo, db_config|
+        memo.merge(db_config.to_legacy_hash)
+      end
+
+      Hash[configs.to_a.reverse]
+    end
+
+    # Checks if the application's configurations are empty.
+    #
+    # Aliased to blank?
+    def empty?
+      configurations.empty?
+    end
+    alias :blank? :empty?
+
+    def each
+      throw_getter_deprecation(:each)
+      configurations.each { |config|
+        yield [config.env_name, config.config]
+      }
+    end
+
+    def first
+      throw_getter_deprecation(:first)
+      config = configurations.first
+      [config.env_name, config.config]
+    end
+
+    private
+      def env_with_configs(env = nil)
+        if env
+          configurations.select { |db_config| db_config.env_name == env }
+        else
+          configurations
+        end
+      end
+
+      def build_configs(configs)
+        return configs.configurations if configs.is_a?(DatabaseConfigurations)
+        return configs if configs.is_a?(Array)
+
+        db_configs = configs.flat_map do |env_name, config|
+          if config.is_a?(Hash) && config.all? { |_, v| v.is_a?(Hash) }
+            walk_configs(env_name.to_s, config)
+          else
+            build_db_config_from_raw_config(env_name.to_s, "primary", config)
+          end
+        end
+
+        current_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_s
+
+        unless db_configs.find(&:for_current_env?)
+          db_configs << environment_url_config(current_env, "primary", {})
+        end
+
+        merge_db_environment_variables(current_env, db_configs.compact)
+      end
+
+      def walk_configs(env_name, config)
+        config.map do |spec_name, sub_config|
+          build_db_config_from_raw_config(env_name, spec_name.to_s, sub_config)
+        end
+      end
+
+      def build_db_config_from_raw_config(env_name, spec_name, config)
+        case config
+        when String
+          build_db_config_from_string(env_name, spec_name, config)
+        when Hash
+          build_db_config_from_hash(env_name, spec_name, config.stringify_keys)
+        else
+          raise InvalidConfigurationError, "'{ #{env_name} => #{config} }' is not a valid configuration. Expected '#{config}' to be a URL string or a Hash."
+        end
+      end
+
+      def build_db_config_from_string(env_name, spec_name, config)
+        url = config
+        uri = URI.parse(url)
+        if uri.scheme
+          ActiveRecord::DatabaseConfigurations::UrlConfig.new(env_name, spec_name, url)
+        else
+          raise InvalidConfigurationError, "'{ #{env_name} => #{config} }' is not a valid configuration. Expected '#{config}' to be a URL string or a Hash."
+        end
+      end
+
+      def build_db_config_from_hash(env_name, spec_name, config)
+        if config.has_key?("url")
+          url = config["url"]
+          config_without_url = config.dup
+          config_without_url.delete "url"
+
+          ActiveRecord::DatabaseConfigurations::UrlConfig.new(env_name, spec_name, url, config_without_url)
+        else
+          ActiveRecord::DatabaseConfigurations::HashConfig.new(env_name, spec_name, config)
+        end
+      end
+
+      def merge_db_environment_variables(current_env, configs)
+        configs.map do |config|
+          next config if config.url_config? || config.env_name != current_env
+
+          url_config = environment_url_config(current_env, config.spec_name, config.config)
+          url_config || config
+        end
+      end
+
+      def environment_url_config(env, spec_name, config)
+        url = environment_value_for(spec_name)
+        return unless url
+
+        ActiveRecord::DatabaseConfigurations::UrlConfig.new(env, spec_name, url, config)
+      end
+
+      def environment_value_for(spec_name)
+        spec_env_key = "#{spec_name.upcase}_DATABASE_URL"
+        url = ENV[spec_env_key]
+        url ||= ENV["DATABASE_URL"] if spec_name == "primary"
+        url
+      end
+
+      def method_missing(method, *args, &blk)
+        case method
+        when :fetch
+          throw_getter_deprecation(method)
+          configs_for(env_name: args.first)
+        when :values
+          throw_getter_deprecation(method)
+          configurations.map(&:config)
+        when :[]=
+          throw_setter_deprecation(method)
+
+          env_name = args[0]
+          config = args[1]
+
+          remaining_configs = configurations.reject { |db_config| db_config.env_name == env_name }
+          new_config = build_configs(env_name => config)
+          new_configs = remaining_configs + new_config
+
+          ActiveRecord::Base.configurations = new_configs
+        else
+          raise NotImplementedError, "`ActiveRecord::Base.configurations` in Rails 6 now returns an object instead of a hash. The `#{method}` method is not supported. Please use `configs_for` or consult the documentation for supported methods."
+        end
+      end
+
+      def throw_setter_deprecation(method)
+        ActiveSupport::Deprecation.warn("Setting `ActiveRecord::Base.configurations` with `#{method}` is deprecated. Use `ActiveRecord::Base.configurations=` directly to set the configurations instead.")
+      end
+
+      def throw_getter_deprecation(method)
+        ActiveSupport::Deprecation.warn("`ActiveRecord::Base.configurations` no longer returns a hash. Methods that act on the hash like `#{method}` are deprecated and will be removed in Rails 6.1. Use the `configs_for` method to collect and iterate over the database configurations.")
+      end
+  end
+end

data/lib/active_record/define_callbacks.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # This module exists because ActiveRecord::AttributeMethods::Dirty needs to
+  # define callbacks, but continue to have its version of +save+ be the super
+  # method of ActiveRecord::Callbacks. This will be removed when the removal
+  # of deprecated code removes this need.
+  module DefineCallbacks
+    extend ActiveSupport::Concern
+
+    module ClassMethods # :nodoc:
+      include ActiveModel::Callbacks
+    end
+
+    included do
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :find, :touch, only: :after
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+  end
+end