activerecord 7.1.3.4 → 7.2.0.beta1

data/lib/active_record/core.rb

@@ -73,7 +73,7 @@ module ActiveRecord
       end
       self.configurations = {}
 
-      # Returns fully resolved ActiveRecord::DatabaseConfigurations object
+      # Returns a fully resolved ActiveRecord::DatabaseConfigurations object.
       def self.configurations
         @@configurations
       end
@@ -102,6 +102,9 @@ module ActiveRecord
 
       class_attribute :shard_selector, instance_accessor: false, default: nil
 
+      # Specifies the attributes that will be included in the output of the #inspect method
+      class_attribute :attributes_for_inspect, instance_accessor: false, default: [:id]
+
       def self.application_record_class? # :nodoc:
         if ActiveRecord.application_record_class
           self == ActiveRecord.application_record_class
@@ -351,7 +354,7 @@ module ActiveRecord
         elsif abstract_class?
           "#{super}(abstract)"
         elsif !connected?
-          "#{super} (call '#{super}.connection' to establish a connection)"
+          "#{super} (call '#{super}.lease_connection' to establish a connection)"
         elsif table_exists?
           attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
           "#{super}(#{attr_list})"
@@ -373,7 +376,7 @@ module ActiveRecord
         TypeCaster::Map.new(self)
       end
 
-      def cached_find_by_statement(key, &block) # :nodoc:
+      def cached_find_by_statement(connection, key, &block) # :nodoc:
         cache = @find_by_statement_cache[connection.prepared_statements]
         cache.compute_if_absent(key) { StatementCache.create(connection, &block) }
       end
@@ -396,8 +399,8 @@ module ActiveRecord
             @arel_table = nil
             @predicate_builder = nil
             @inspection_filter = nil
-            @filter_attributes = nil
-            @generated_association_methods = nil
+            @filter_attributes ||= nil
+            @generated_association_methods ||= nil
           end
         end
 
@@ -416,21 +419,23 @@ module ActiveRecord
         end
 
         def cached_find_by(keys, values)
-          statement = cached_find_by_statement(keys) { |params|
-            wheres = keys.index_with do |key|
-              if key.is_a?(Array)
-                [key.map { params.bind }]
-              else
-                params.bind
+          with_connection do |connection|
+            statement = cached_find_by_statement(connection, keys) { |params|
+              wheres = keys.index_with do |key|
+                if key.is_a?(Array)
+                  [key.map { params.bind }]
+                else
+                  params.bind
+                end
               end
-            end
-            where(wheres).limit(1)
-          }
+              where(wheres).limit(1)
+            }
 
-          begin
-            statement.execute(values.flatten, connection).first
-          rescue TypeError
-            raise ActiveRecord::StatementInvalid
+            begin
+              statement.execute(values.flatten, connection, allow_retry: true).first
+            rescue TypeError
+              raise ActiveRecord::StatementInvalid
+            end
           end
         end
     end
@@ -450,7 +455,7 @@ module ActiveRecord
       init_internals
       initialize_internals_callback
 
-      assign_attributes(attributes) if attributes
+      super
 
       yield self if block_given?
       _run_initialize_callbacks
@@ -701,6 +706,11 @@ module ActiveRecord
       @strict_loading_mode == :n_plus_one_only
     end
 
+    # Returns +true+ if the record uses strict_loading with +:all+ mode enabled.
+    def strict_loading_all?
+      @strict_loading_mode == :all
+    end
+
     # Marks this record as read only.
     #
     #   customer = Customer.first
@@ -714,21 +724,14 @@ module ActiveRecord
       self.class.connection_handler
     end
 
-    # Returns the contents of the record as a nicely formatted string.
+    # Returns the attributes specified by <tt>.attributes_for_inspect</tt> as a nicely formatted string.
     def inspect
-      # We check defined?(@attributes) not to issue warnings if the object is
-      # allocated but not initialized.
-      inspection = if defined?(@attributes) && @attributes
-        attribute_names.filter_map do |name|
-          if _has_attribute?(name)
-            "#{name}: #{attribute_for_inspect(name)}"
-          end
-        end.join(", ")
-      else
-        "not initialized"
-      end
+      inspect_with_attributes(attributes_for_inspect)
+    end
 
-      "#<#{self.class} #{inspection}>"
+    # Returns the full contents of the record as a nicely formatted string.
+    def full_inspect
+      inspect_with_attributes(attribute_names)
     end
 
     # Takes a PP and prettily prints this record to it, allowing you to get a nice result from <tt>pp record</tt>
@@ -736,17 +739,17 @@ module ActiveRecord
     def pretty_print(pp)
       return super if custom_inspect_method_defined?
       pp.object_address_group(self) do
-        if defined?(@attributes) && @attributes
-          attr_names = self.class.attribute_names.select { |name| _has_attribute?(name) }
+        if @attributes
+          attr_names = attributes_for_inspect.select { |name| _has_attribute?(name.to_s) }
           pp.seplist(attr_names, proc { pp.text "," }) do |attr_name|
+            attr_name = attr_name.to_s
             pp.breakable " "
             pp.group(1) do
               pp.text attr_name
               pp.text ":"
               pp.breakable
-              value = _read_attribute(attr_name)
-              value = inspection_filter.filter_param(attr_name, value) unless value.nil?
-              pp.pp value
+              value = attribute_for_inspect(attr_name)
+              pp.text value
             end
           end
         else
@@ -784,7 +787,6 @@ module ActiveRecord
         @strict_loading_mode = :all
 
         klass.define_attribute_methods
-        klass.generate_alias_attributes
       end
 
       def initialize_internals_callback
@@ -804,5 +806,24 @@ module ActiveRecord
       def inspection_filter
         self.class.inspection_filter
       end
+
+      def inspect_with_attributes(attributes_to_list)
+        inspection = if @attributes
+          attributes_to_list.filter_map do |name|
+            name = name.to_s
+            if _has_attribute?(name)
+              "#{name}: #{attribute_for_inspect(name)}"
+            end
+          end.join(", ")
+        else
+          "not initialized"
+        end
+
+        "#<#{self.class} #{inspection}>"
+      end
+
+      def attributes_for_inspect
+        self.class.attributes_for_inspect == :all ? attribute_names : self.class.attributes_for_inspect
+      end
   end
 end

data/lib/active_record/counter_cache.rb

@@ -7,6 +7,7 @@ module ActiveRecord
 
     included do
       class_attribute :_counter_cache_columns, instance_accessor: false, default: []
+      class_attribute :counter_cached_association_names, instance_writer: false, default: []
     end
 
     module ClassMethods
@@ -65,7 +66,7 @@ module ActiveRecord
           updates.merge!(touch_updates)
         end
 
-        unscoped.where(primary_key => object.id).update_all(updates) if updates.any?
+        unscoped.where(primary_key => [object.id]).update_all(updates) if updates.any?
 
         true
       end
@@ -112,6 +113,7 @@ module ActiveRecord
       #   #    `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
 
@@ -180,14 +182,26 @@ module ActiveRecord
       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
 
     private
       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
@@ -197,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
@@ -208,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

@@ -25,8 +25,7 @@ module ActiveRecord
       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"
+        @adapter = resolved_adapter
 
         if @uri.opaque
           @uri.opaque, @query = @uri.opaque.split("?", 2)
@@ -80,6 +79,12 @@ module ActiveRecord
           end
         end
 
+        def resolved_adapter
+          adapter = uri.scheme && @uri.scheme.tr("-", "_")
+          adapter = ActiveRecord.protocol_adapters[adapter] || adapter
+          adapter
+        end
+
         # Returns name of the database.
         def database_from_path
           if @adapter == "sqlite3"

data/lib/active_record/database_configurations/database_config.rb

@@ -11,14 +11,21 @@ module ActiveRecord
       def initialize(env_name, name)
         @env_name = env_name
         @name = name
+        @adapter_class = nil
       end
 
-      def adapter_method
-        "#{adapter}_connection"
+      def adapter_class
+        @adapter_class ||= ActiveRecord::ConnectionAdapters.resolve(adapter)
       end
 
-      def adapter_class_method
-        "#{adapter}_adapter_class"
+      def new_connection
+        adapter_class.new(configuration_hash)
+      end
+
+      def validate!
+        adapter_class if adapter
+
+        true
       end
 
       def host
@@ -84,6 +91,10 @@ module ActiveRecord
       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,53 +1,54 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActiveRecord
   class DatabaseConfigurations
-    # = Active Record Database Hash Config
+    # # Active Record Database Hash Config
     #
-    # A +HashConfig+ object is created for each database configuration entry that
-    # is created from a hash.
+    # 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", @name="primary", @config={database: "db_name"}>
+    #     #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10
+    #       @env_name="development", @name="primary", @config={database: "db_name"}>
     #
     # See ActiveRecord::DatabaseConfigurations for more info.
     class HashConfig < DatabaseConfig
       attr_reader :configuration_hash
 
-
-      # Initialize a new +HashConfig+ object
+      # Initialize a new `HashConfig` object
       #
-      # ==== Options
+      # #### 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.
       #
-      # * <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.
       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?
         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
         configuration_hash[:migrations_paths]
       end
@@ -92,8 +93,8 @@ module ActiveRecord
         (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+.
+      # `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
@@ -104,18 +105,21 @@ module ActiveRecord
       end
 
       def adapter
-        configuration_hash[: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.
+      # 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/schema_cache.yml"
+      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
@@ -126,14 +130,14 @@ module ActiveRecord
         Base.configurations.primary?(name)
       end
 
-      # Determines whether to dump the schema/structure files and the
-      # filename that should be used.
+      # 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 `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.
+      # 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]
@@ -150,6 +154,10 @@ module ActiveRecord
         !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

data/lib/active_record/database_configurations/url_config.rb

@@ -41,10 +41,29 @@ module ActiveRecord
         super(env_name, name, configuration_hash)
 
         @url = url
-        @configuration_hash = @configuration_hash.merge(build_url_hash).freeze
+        @configuration_hash = @configuration_hash.merge(build_url_hash)
+
+        if @configuration_hash[:schema_dump] == "false"
+          @configuration_hash[:schema_dump] = false
+        end
+
+        if @configuration_hash[:query_cache] == "false"
+          @configuration_hash[:query_cache] = false
+        end
+
+        to_boolean!(@configuration_hash, :replica)
+        to_boolean!(@configuration_hash, :database_tasks)
+
+        @configuration_hash.freeze
       end
 
       private
+        def to_boolean!(configuration_hash, key)
+          if configuration_hash[key].is_a?(String)
+            configuration_hash[key] = configuration_hash[key] != "false"
+          end
+        end
+
         # Return a Hash that can be merged into the main config that represents
         # the passed in url
         def build_url_hash

data/lib/active_record/database_configurations.rb

@@ -113,7 +113,7 @@ module ActiveRecord
 
       if name
         configs.find do |db_config|
-          db_config.name == name
+          db_config.name == name.to_s
         end
       else
         configs

data/lib/active_record/delegated_type.rb

@@ -36,7 +36,7 @@ module ActiveRecord
   #
   # Let's look at that entry/message/comment example using delegated types:
   #
-  #   # Schema: entries[ id, account_id, creator_id, created_at, updated_at, entryable_type, entryable_id ]
+  #   # Schema: entries[ id, account_id, creator_id, entryable_type, entryable_id, created_at, updated_at ]
   #   class Entry < ApplicationRecord
   #     belongs_to :account
   #     belongs_to :creator
@@ -51,12 +51,12 @@ module ActiveRecord
   #     end
   #   end
   #
-  #   # Schema: messages[ id, subject, body ]
+  #   # Schema: messages[ id, subject, body, created_at, updated_at ]
   #   class Message < ApplicationRecord
   #     include Entryable
   #   end
   #
-  #   # Schema: comments[ id, content ]
+  #   # Schema: comments[ id, content, created_at, updated_at ]
   #   class Comment < ApplicationRecord
   #     include Entryable
   #   end
@@ -102,17 +102,37 @@ module ActiveRecord
   # You create a new record that uses delegated typing by creating the delegator and delegatee at the same time,
   # like so:
   #
-  #   Entry.create! entryable: Comment.new(content: "Hello!"), creator: Current.user
+  #   Entry.create! entryable: Comment.new(content: "Hello!"), creator: Current.user, account: Current.account
   #
   # If you need more complicated composition, or you need to perform dependent validation, you should build a factory
   # method or class to take care of the complicated needs. This could be as simple as:
   #
   #   class Entry < ApplicationRecord
-  #     def self.create_with_comment(content, creator: Current.user)
-  #       create! entryable: Comment.new(content: content), creator: creator
+  #     def self.create_with_comment(content, creator: Current.user, account: Current.account)
+  #       create! entryable: Comment.new(content: content), creator: creator, account: account
   #     end
   #   end
   #
+  # == Querying across records
+  #
+  # A consequence of delegated types is that querying attributes spread across multiple classes becomes slightly more
+  # tricky, but not impossible.
+  #
+  # The simplest method is to join the "superclass" to the "subclass" and apply the query parameters (i.e. <tt>#where</tt>)
+  # in appropriate places:
+  #
+  #   Comment.joins(:entry).where(comments: { content: 'Hello!' }, entry: { creator: Current.user } )
+  #
+  # For convenience, add a scope on the concern. Now all classes that implement the concern will automatically include
+  # the method:
+  #
+  #   # app/models/concerns/entryable.rb
+  #   scope :with_entry, ->(attrs) { joins(:entry).where(entry: attrs) }
+  #
+  # Now the query can be shortened significantly:
+  #
+  #   Comment.where(content: 'Hello!').with_entry(creator: Current.user)
+  #
   # == Adding further delegation
   #
   # The delegated type shouldn't just answer the question of what the underlying class is called. In fact, that's
@@ -219,6 +239,10 @@ module ActiveRecord
         role_type = options[:foreign_type] || "#{role}_type"
         role_id   = options[:foreign_key] || "#{role}_id"
 
+        define_singleton_method "#{role}_types" do
+          types.map(&:to_s)
+        end
+
         define_method "#{role}_class" do
           public_send(role_type).constantize
         end

data/lib/active_record/destroy_association_async_job.rb

@@ -19,7 +19,7 @@ module ActiveRecord
     )
       association_model = association_class.constantize
       owner_class = owner_model_name.constantize
-      owner = owner_class.find_by(owner_class.primary_key.to_sym => owner_id)
+      owner = owner_class.find_by(owner_class.primary_key => [owner_id])
 
       if !owner_destroyed?(owner, ensuring_owner_was_method)
         raise DestroyAssociationAsyncError, "owner record not destroyed"

data/lib/active_record/dynamic_matchers.rb

@@ -12,12 +12,12 @@ module ActiveRecord
         end
       end
 
-      def method_missing(name, *arguments, &block)
+      def method_missing(name, ...)
         match = Method.match(self, name)
 
         if match && match.valid?
           match.define
-          send(name, *arguments, &block)
+          send(name, ...)
         else
           super
         end

data/lib/active_record/encryption/encryptable_record.rb

@@ -84,7 +84,7 @@ module ActiveRecord
           def encrypt_attribute(name, key_provider: nil, key: nil, deterministic: false, support_unencrypted_data: nil, downcase: false, ignore_case: false, previous: [], **context_properties)
             encrypted_attributes << name.to_sym
 
-            attribute name do |cast_type|
+            decorate_attributes([name]) do |name, cast_type|
               scheme = scheme_for key_provider: key_provider, key: key, deterministic: deterministic, support_unencrypted_data: support_unencrypted_data, \
                 downcase: downcase, ignore_case: ignore_case, previous: previous, **context_properties
 
@@ -221,7 +221,7 @@ module ActiveRecord
         end
 
         def cant_modify_encrypted_attributes_when_frozen
-          self.class&.encrypted_attributes.each do |attribute|
+          self.class.encrypted_attributes.each do |attribute|
             errors.add(attribute.to_sym, "can't be modified because it is encrypted") if changed_attributes.include?(attribute)
           end
         end