activerecord 4.2.9 → 6.1.4.1

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/connection_url_resolver.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
+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 = @uri.scheme && @uri.scheme.tr("-", "_")
+        @adapter = "postgresql" if @adapter == "postgres"
+
+        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::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.merge(
+              adapter: @adapter,
+              username: uri.user,
+              password: uri.password,
+              port: uri.port,
+              database: database_from_path,
+              host: uri.hostname
+            )
+          end
+        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

@@ -0,0 +1,80 @@
+# 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, :name
+
+      attr_accessor :owner_name
+
+      def initialize(env_name, name)
+        @env_name = env_name
+        @name = name
+      end
+
+      def spec_name
+        @name
+      end
+      deprecate spec_name: "please use name instead"
+
+      def config
+        raise NotImplementedError
+      end
+
+      def adapter_method
+        "#{adapter}_connection"
+      end
+
+      def host
+        raise NotImplementedError
+      end
+
+      def database
+        raise NotImplementedError
+      end
+
+      def _database=(database)
+        raise NotImplementedError
+      end
+
+      def adapter
+        raise NotImplementedError
+      end
+
+      def pool
+        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
+    end
+  end
+end

data/lib/active_record/database_configurations/hash_config.rb

@@ -0,0 +1,96 @@
+# 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", @name="primary", @config={database: "db_name"}>
+    #
+    # ==== Options
+    #
+    # * <tt>:env_name</tt> - The Rails environment, i.e. "development".
+    # * <tt>:name</tt> - 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".
+    # * <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 :configuration_hash
+      def initialize(env_name, name, configuration_hash)
+        super(env_name, name)
+        @configuration_hash = configuration_hash.symbolize_keys.freeze
+      end
+
+      def config
+        ActiveSupport::Deprecation.warn("DatabaseConfig#config will be removed in 6.2.0 in favor of DatabaseConfigurations#configuration_hash which returns a hash with symbol keys")
+        configuration_hash.stringify_keys
+      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?
+        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.
+      def migrations_paths
+        configuration_hash[:migrations_paths]
+      end
+
+      def host
+        configuration_hash[:host]
+      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 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]
+      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
+    end
+  end
+end

data/lib/active_record/database_configurations/url_config.rb

@@ -0,0 +1,53 @@
+# 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", @name="primary",
+    #     @config={adapter: "postgresql", database: "foo", host: "localhost"},
+    #     @url="postgres://localhost/foo">
+    #
+    # ==== Options
+    #
+    # * <tt>:env_name</tt> - The Rails environment, ie "development".
+    # * <tt>:name</tt> - 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".
+    # * <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 < HashConfig
+      attr_reader :url
+
+      def initialize(env_name, name, url, configuration_hash = {})
+        super(env_name, name, configuration_hash)
+
+        @url = url
+        @configuration_hash = @configuration_hash.merge(build_url_hash).freeze
+      end
+
+      private
+        # Return a Hash that can be merged into the main config that represents
+        # the passed in url
+        def build_url_hash
+          if url.nil? || %w(jdbc: http: https:).any? { |protocol| url.start_with?(protocol) }
+            { url: url }
+          else
+            ConnectionUrlResolver.new(url).to_hash
+          end
+        end
+    end
+  end
+end