activerecord 6.0.0 → 7.2.3

data/lib/active_record/counter_cache.rb

@@ -5,6 +5,11 @@ module ActiveRecord
   module CounterCache
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :_counter_cache_columns, instance_accessor: false, default: []
+      class_attribute :counter_cached_association_names, instance_writer: false, default: []
+    end
+
     module ClassMethods
       # Resets one or more counter caches to their correct value using an SQL
       # count query. This is useful when adding new counter caches, or if the
@@ -23,12 +28,13 @@ module ActiveRecord
       #   # For the Post with id #1, reset the comments_count
       #   Post.reset_counters(1, :comments)
       #
-      #   # Like above, but also touch the +updated_at+ and/or +updated_on+
+      #   # 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)
 
+        updates = {}
         counters.each do |counter_association|
           has_many_association = _reflect_on_association(counter_association)
           unless has_many_association
@@ -47,16 +53,21 @@ 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
 
-          updates = { counter_name => object.send(counter_association).count(:all) }
-
-          if touch
-            names = touch if touch != true
-            updates.merge!(touch_attributes_with_time(*names))
-          end
+          count_was = object.send(counter_name)
+          count = object.send(counter_association).count(:all)
+          updates[counter_name] = count if count != count_was
+        end
 
-          unscoped.where(primary_key => object.id).update_all(updates)
+        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) if updates.any?
+
         true
       end
 
@@ -77,31 +88,32 @@ module ActiveRecord
       #
       # ==== Examples
       #
-      #   # For the Post with id of 5, decrement the comment_count by 1, and
-      #   # increment the action_count by 1
-      #   Post.update_counters 5, comment_count: -1, action_count: 1
+      #   # For the Post with id of 5, decrement the comments_count by 1, and
+      #   # increment the actions_count by 1
+      #   Post.update_counters 5, comments_count: -1, actions_count: 1
       #   # Executes the following SQL:
       #   # UPDATE posts
-      #   #    SET comment_count = COALESCE(comment_count, 0) - 1,
-      #   #        action_count = COALESCE(action_count, 0) + 1
+      #   #    SET comments_count = COALESCE(comments_count, 0) - 1,
+      #   #        actions_count = COALESCE(actions_count, 0) + 1
       #   #  WHERE id = 5
       #
-      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
-      #   Post.update_counters [10, 15], comment_count: 1
+      #   # For the Posts with id of 10 and 15, increment the comments_count by 1
+      #   Post.update_counters [10, 15], comments_count: 1
       #   # Executes the following SQL:
       #   # UPDATE posts
-      #   #    SET comment_count = COALESCE(comment_count, 0) + 1
+      #   #    SET comments_count = COALESCE(comments_count, 0) + 1
       #   #  WHERE id IN (10, 15)
       #
-      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
+      #   # For the Posts with id of 10 and 15, increment the comments_count by 1
       #   # and update the updated_at value for each counter.
-      #   Post.update_counters [10, 15], comment_count: 1, touch: true
+      #   Post.update_counters [10, 15], comments_count: 1, touch: true
       #   # Executes the following SQL:
       #   # UPDATE posts
-      #   #    SET comment_count = COALESCE(comment_count, 0) + 1,
+      #   #    SET comments_count = COALESCE(comments_count, 0) + 1,
       #   #    `updated_at` = '2016-10-13T09:59:23-05:00'
       #   #  WHERE id IN (10, 15)
       def update_counters(id, counters)
+        id = [id] if composite_primary_key? && id.is_a?(Array) && !id[0].is_a?(Array)
         unscoped.where!(primary_key => id).update_counters(counters)
       end
 
@@ -116,6 +128,7 @@ module ActiveRecord
       #
       # * +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.
+      # * <tt>:by</tt> - The amount by which to increment the value. Defaults to +1+.
       # * <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.
@@ -126,10 +139,14 @@ module ActiveRecord
       #   DiscussionBoard.increment_counter(:posts_count, 5)
       #
       #   # Increment the posts_count column for the record with an id of 5
+      #   # by a specific amount.
+      #   DiscussionBoard.increment_counter(:posts_count, 5, by: 3)
+      #
+      #   # 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)
+      def increment_counter(counter_name, id, by: 1, touch: nil)
+        update_counters(id, counter_name => by, touch: touch)
       end
 
       # Decrement a numeric field by one, via a direct SQL update.
@@ -141,6 +158,7 @@ module ActiveRecord
       #
       # * +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.
+      # * <tt>:by</tt> - The amount by which to decrement the value. Defaults to +1+.
       # * <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.
@@ -151,10 +169,30 @@ module ActiveRecord
       #   DiscussionBoard.decrement_counter(:posts_count, 5)
       #
       #   # Decrement the posts_count column for the record with an id of 5
+      #   by a specific amount.
+      #   DiscussionBoard.decrement_counter(:posts_count, 5, by: 3)
+      #
+      #   # 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)
+      def decrement_counter(counter_name, id, by: 1, touch: nil)
+        update_counters(id, counter_name => -by, touch: touch)
+      end
+
+      def counter_cache_column?(name) # :nodoc:
+        _counter_cache_columns.include?(name)
+      end
+
+      def load_schema! # :nodoc:
+        super
+
+        association_names = _reflections.filter_map do |name, reflection|
+          next unless reflection.belongs_to? && reflection.counter_cache_column
+
+          name.to_sym
+        end
+
+        self.counter_cached_association_names |= association_names
       end
     end
 
@@ -162,8 +200,8 @@ module ActiveRecord
       def _create_record(attribute_names = self.attribute_names)
         id = super
 
-        each_counter_cached_associations do |association|
-          association.increment_counters
+        counter_cached_association_names.each do |association_name|
+          association(association_name).increment_counters
         end
 
         id
@@ -173,9 +211,10 @@ module ActiveRecord
         affected_rows = super
 
         if affected_rows > 0
-          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
+          counter_cached_association_names.each do |association_name|
+            association = association(association_name)
+
+            unless destroyed_by_association && _foreign_keys_equal?(destroyed_by_association.foreign_key, association.reflection.foreign_key)
               association.decrement_counters
             end
           end
@@ -184,10 +223,8 @@ module ActiveRecord
         affected_rows
       end
 
-      def each_counter_cached_associations
-        _reflections.each do |name, reflection|
-          yield association(name.to_sym) if reflection.belongs_to? && reflection.counter_cache_column
-        end
+      def _foreign_keys_equal?(fkey1, fkey2)
+        fkey1 == fkey2 || Array(fkey1).map(&:to_sym) == Array(fkey2).map(&:to_sym)
       end
   end
 end

data/lib/active_record/database_configurations/connection_url_resolver.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "uri"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/reverse_merge"
+
+module ActiveRecord
+  class DatabaseConfigurations
+    # Expands a connection string into a hash.
+    class ConnectionUrlResolver # :nodoc:
+      # == Example
+      #
+      #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
+      #   ConnectionUrlResolver.new(url).to_hash
+      #   # => {
+      #     adapter:  "postgresql",
+      #     host:     "localhost",
+      #     port:     9000,
+      #     database: "foo_test",
+      #     username: "foo",
+      #     password: "bar",
+      #     pool:     "5",
+      #     timeout:  "3000"
+      #   }
+      def initialize(url)
+        raise "Database URL cannot be empty" if url.blank?
+        @uri     = uri_parser.parse(url)
+        @adapter = resolved_adapter
+
+        if @uri.opaque
+          @uri.opaque, @query = @uri.opaque.split("?", 2)
+        else
+          @query = @uri.query
+        end
+      end
+
+      # Converts the given URL to a full connection hash.
+      def to_hash
+        config = raw_config.compact_blank
+        config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
+        config
+      end
+
+      private
+        attr_reader :uri
+
+        def uri_parser
+          @uri_parser ||= URI::RFC2396_Parser.new
+        end
+
+        # Converts the query parameters of the URI into a hash.
+        #
+        #   "localhost?pool=5&reaping_frequency=2"
+        #   # => { pool: "5", reaping_frequency: "2" }
+        #
+        # returns empty hash if no query present.
+        #
+        #   "localhost"
+        #   # => {}
+        def query_hash
+          Hash[(@query || "").split("&").map { |pair| pair.split("=", 2) }].symbolize_keys
+        end
+
+        def raw_config
+          if uri.opaque
+            query_hash.merge(
+              adapter: @adapter,
+              database: uri.opaque
+            )
+          else
+            query_hash.reverse_merge(
+              adapter: @adapter,
+              username: uri.user,
+              password: uri.password,
+              port: uri.port,
+              database: database_from_path,
+              host: uri.hostname
+            )
+          end
+        end
+
+        def resolved_adapter
+          adapter = uri.scheme && @uri.scheme.tr("-", "_")
+          if adapter && ActiveRecord.protocol_adapters[adapter]
+            adapter = ActiveRecord.protocol_adapters[adapter]
+          end
+          adapter
+        end
+
+        # Returns name of the database.
+        def database_from_path
+          if @adapter == "sqlite3"
+            # 'sqlite3:/foo' is absolute, because that makes sense. The
+            # corresponding relative version, 'sqlite3:foo', is handled
+            # elsewhere, as an "opaque".
+
+            uri.path
+          else
+            # Only SQLite uses a filename as the "database" name; for
+            # anything else, a leading slash would be silly.
+
+            uri.path.delete_prefix("/")
+          end
+        end
+    end
+  end
+end

data/lib/active_record/database_configurations/database_config.rb

@@ -3,35 +3,102 @@
 module ActiveRecord
   class DatabaseConfigurations
     # ActiveRecord::Base.configurations will return either a HashConfig or
-    # UrlConfig respectively. It will never return a DatabaseConfig object,
+    # 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
+      attr_reader :env_name, :name
 
-      def initialize(env_name, spec_name)
+      def initialize(env_name, name)
         @env_name = env_name
-        @spec_name = spec_name
+        @name = name
+        @adapter_class = nil
       end
 
-      def replica?
+      def adapter_class
+        @adapter_class ||= ActiveRecord::ConnectionAdapters.resolve(adapter)
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name} env_name=#{@env_name} name=#{@name} adapter_class=#{adapter_class}>"
+      end
+
+      def new_connection
+        adapter_class.new(configuration_hash)
+      end
+
+      def validate!
+        adapter_class if adapter
+
+        true
+      end
+
+      def host
         raise NotImplementedError
       end
 
-      def migrations_paths
+      def database
+        raise NotImplementedError
+      end
+
+      def _database=(database)
         raise NotImplementedError
       end
 
-      def url_config?
-        false
+      def adapter
+        raise NotImplementedError
       end
 
-      def to_legacy_hash
-        { env_name => config }
+      def pool
+        raise NotImplementedError
+      end
+
+      def min_threads
+        raise NotImplementedError
+      end
+
+      def max_threads
+        raise NotImplementedError
+      end
+
+      def max_queue
+        raise NotImplementedError
+      end
+
+      def query_cache
+        raise NotImplementedError
+      end
+
+      def checkout_timeout
+        raise NotImplementedError
+      end
+
+      def reaping_frequency
+        raise NotImplementedError
+      end
+
+      def idle_timeout
+        raise NotImplementedError
+      end
+
+      def replica?
+        raise NotImplementedError
+      end
+
+      def migrations_paths
+        raise NotImplementedError
       end
 
       def for_current_env?
         env_name == ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
       end
+
+      def schema_cache_path
+        raise NotImplementedError
+      end
+
+      def use_metadata_table?
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/active_record/database_configurations/hash_config.rb

@@ -1,50 +1,172 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActiveRecord
   class DatabaseConfigurations
-    # A HashConfig object is created for each database configuration entry that
-    # is created from a hash.
+    # # Active Record Database Hash Config
+    #
+    # A `HashConfig` object is created for each database configuration entry that is
+    # created from a hash.
     #
     # A hash config:
     #
-    #   { "development" => { "database" => "db_name" } }
+    #     { "development" => { "database" => "db_name" } }
     #
     # Becomes:
     #
-    #   #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10
-    #     @env_name="development", @spec_name="primary", @config={"database"=>"db_name"}>
-    #
-    # ==== Options
+    #     #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10
+    #       @env_name="development", @name="primary", @config={database: "db_name"}>
     #
-    # * <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.
+    # See ActiveRecord::DatabaseConfigurations for more info.
     class HashConfig < DatabaseConfig
-      attr_reader :config
+      attr_reader :configuration_hash
 
-      def initialize(env_name, spec_name, config)
-        super(env_name, spec_name)
-        @config = config
+      # Initialize a new `HashConfig` object
+      #
+      # #### Parameters
+      #
+      # *   `env_name` - The Rails environment, i.e. "development".
+      # *   `name` - The db config 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".
+      # *   `configuration_hash` - The config hash. This is the hash that contains the
+      #     database adapter, name, and other important information for database
+      #     connections.
+      #
+      def initialize(env_name, name, configuration_hash)
+        super(env_name, name)
+        @configuration_hash = configuration_hash.symbolize_keys.freeze
       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+.
+      # connection. If the `replica` key is present in the config, `replica?` will
+      # return `true`.
       def replica?
-        config["replica"]
+        configuration_hash[: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.
+      # 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"]
+        configuration_hash[:migrations_paths]
+      end
+
+      def host
+        configuration_hash[:host]
+      end
+
+      def socket # :nodoc:
+        configuration_hash[:socket]
+      end
+
+      def database
+        configuration_hash[:database]
+      end
+
+      def _database=(database) # :nodoc:
+        @configuration_hash = configuration_hash.merge(database: database).freeze
+      end
+
+      def pool
+        (configuration_hash[:pool] || 5).to_i
+      end
+
+      def min_threads
+        (configuration_hash[:min_threads] || 0).to_i
+      end
+
+      def max_threads
+        (configuration_hash[:max_threads] || pool).to_i
+      end
+
+      def query_cache
+        configuration_hash[:query_cache]
+      end
+
+      def max_queue
+        max_threads * 4
+      end
+
+      def checkout_timeout
+        (configuration_hash[:checkout_timeout] || 5).to_f
+      end
+
+      # `reaping_frequency` is configurable mostly for historical reasons, but it
+      # could also be useful if someone wants a very low `idle_timeout`.
+      def reaping_frequency
+        configuration_hash.fetch(:reaping_frequency, 60)&.to_f
+      end
+
+      def idle_timeout
+        timeout = configuration_hash.fetch(:idle_timeout, 300).to_f
+        timeout if timeout > 0
+      end
+
+      def adapter
+        configuration_hash[:adapter]&.to_s
+      end
+
+      # The path to the schema cache dump file for a database. If omitted, the
+      # filename will be read from ENV or a default will be derived.
+      def schema_cache_path
+        configuration_hash[:schema_cache_path]
+      end
+
+      def default_schema_cache_path(db_dir = "db")
+        if primary?
+          File.join(db_dir, "schema_cache.yml")
+        else
+          File.join(db_dir, "#{name}_schema_cache.yml")
+        end
       end
+
+      def lazy_schema_cache_path
+        schema_cache_path || default_schema_cache_path
+      end
+
+      def primary? # :nodoc:
+        Base.configurations.primary?(name)
+      end
+
+      # Determines whether to dump the schema/structure files and the filename that
+      # should be used.
+      #
+      # If `configuration_hash[:schema_dump]` is set to `false` or `nil` the schema
+      # will not be dumped.
+      #
+      # If the config option is set that will be used. Otherwise Rails will generate
+      # the filename from the database config name.
+      def schema_dump(format = ActiveRecord.schema_format)
+        if configuration_hash.key?(:schema_dump)
+          if config = configuration_hash[:schema_dump]
+            config
+          end
+        elsif primary?
+          schema_file_type(format)
+        else
+          "#{name}_#{schema_file_type(format)}"
+        end
+      end
+
+      def database_tasks? # :nodoc:
+        !replica? && !!configuration_hash.fetch(:database_tasks, true)
+      end
+
+      def use_metadata_table? # :nodoc:
+        configuration_hash.fetch(:use_metadata_table, true)
+      end
+
+      private
+        def schema_file_type(format)
+          case format
+          when :ruby
+            "schema.rb"
+          when :sql
+            "structure.sql"
+          end
+        end
     end
   end
 end