activerecord 7.0.0.alpha2 → 7.0.0.rc1

data/lib/active_record/database_configurations/hash_config.rb

@@ -32,11 +32,6 @@ module ActiveRecord
         @configuration_hash = configuration_hash.symbolize_keys.freeze
       end
 
-      def config
-        ActiveSupport::Deprecation.warn("DatabaseConfig#config will be removed in 7.0.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+.
@@ -109,14 +104,51 @@ module ActiveRecord
         configuration_hash[:schema_cache_path]
       end
 
-      # Determines whether to dump the schema for a database.
-      def schema_dump
-        configuration_hash.fetch(:schema_dump, true)
+      def default_schema_cache_path
+        "db/schema_cache.yml"
+      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
+
+      private
+        def schema_file_type(format)
+          case format
+          when :ruby
+            "schema.rb"
+          when :sql
+            "structure.sql"
+          end
+        end
     end
   end
 end

data/lib/active_record/database_configurations.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "uri"
 require "active_record/database_configurations/database_config"
 require "active_record/database_configurations/hash_config"
 require "active_record/database_configurations/url_config"
@@ -41,12 +42,7 @@ module ActiveRecord
     #   hidden by +database_tasks: false+ in the returned list. Most of the time we're only
     #   iterating over the primary connections (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, name: nil, include_replicas: false, include_hidden: false)
-      if spec_name
-        name = spec_name
-        ActiveSupport::Deprecation.warn("The kwarg `spec_name` is deprecated in favor of `name`. `spec_name` will be removed in Rails 7.0")
-      end
-
+    def configs_for(env_name: nil, name: nil, include_replicas: false, include_hidden: false)
       if include_replicas
         include_hidden = include_replicas
         ActiveSupport::Deprecation.warn("The kwarg `include_replicas` is deprecated in favor of `include_hidden`. When `include_hidden` is passed, configurations with `replica: true` or `database_tasks: false` will be returned. `include_replicas` will be removed in Rails 7.1.")
@@ -70,19 +66,6 @@ module ActiveRecord
       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 = default_env)
-      default = find_db_config(env)
-      default.configuration_hash if default
-    end
-    alias :[] :default_hash
-    deprecate "[]": "Use configs_for", default_hash: "Use configs_for"
-
     # Returns a single DatabaseConfig object based on the requested environment.
     #
     # If the application has multiple databases +find_db_config+ will return
@@ -109,14 +92,6 @@ module ActiveRecord
       first_config && name == first_config.name
     end
 
-    # Returns the DatabaseConfigurations object as a Hash.
-    def to_h
-      configurations.inject({}) do |memo, db_config|
-        memo.merge(db_config.env_name => db_config.configuration_hash.stringify_keys)
-      end
-    end
-    deprecate to_h: "You can use `ActiveRecord::Base.configurations.configs_for(env_name: 'env', name: 'primary').configuration_hash` to get the configuration hashes."
-
     # Checks if the application's configurations are empty.
     #
     # Aliased to blank?

data/lib/active_record/delegated_type.rb

@@ -137,6 +137,21 @@ module ActiveRecord
   #   end
   #
   # Now you can list a bunch of entries, call +Entry#title+, and polymorphism will provide you with the answer.
+  #
+  # == Nested Attributes
+  #
+  # Enabling nested attributes on a delegated_type association allows you to
+  # create the entry and message in one go:
+  #
+  #   class Entry < ApplicationRecord
+  #     delegated_type :entryable, types: %w[ Message Comment ]
+  #     accepts_nested_attributes_for :entryable
+  #   end
+  #
+  #   params = { entry: { entryable_type: 'Message', entryable_attributes: { subject: 'Smiling' } } }
+  #   entry = Entry.create(params[:entry])
+  #   entry.entryable.id # => 2
+  #   entry.entryable.subject # => 'Smiling'
   module DelegatedType
     # Defines this as a class that'll delegate its type for the passed +role+ to the class references in +types+.
     # That'll create a polymorphic +belongs_to+ relationship to that +role+, and it'll add all the delegated
@@ -207,6 +222,10 @@ module ActiveRecord
           public_send("#{role}_class").model_name.singular.inquiry
         end
 
+        define_method "build_#{role}" do |*params|
+          public_send("#{role}=", public_send("#{role}_class").new(*params))
+        end
+
         types.each do |type|
           scope_name = type.tableize.tr("/", "_")
           singular   = scope_name.singularize

data/lib/active_record/encryption/encrypted_attribute_type.rb

@@ -17,7 +17,7 @@ module ActiveRecord
 
       # === Options
       #
-      # * <tt>:scheme</tt> - An +Scheme+ with the encryption properties for this attribute.
+      # * <tt>:scheme</tt> - A +Scheme+ with the encryption properties for this attribute.
       # * <tt>:cast_type</tt> - A type that will be used to serialize (before encrypting) and deserialize
       #   (after decrypting). +ActiveModel::Type::String+ by default.
       def initialize(scheme:, cast_type: ActiveModel::Type::String.new, previous_type: false)

data/lib/active_record/encryption/extended_deterministic_uniqueness_validator.rb

@@ -12,7 +12,7 @@ module ActiveRecord
           super(record, attribute, value)
 
           klass = record.class
-          if klass.deterministic_encrypted_attributes&.each do |attribute_name|
+          klass.deterministic_encrypted_attributes&.each do |attribute_name|
             encrypted_type = klass.type_for_attribute(attribute_name)
             [ encrypted_type, *encrypted_type.previous_types ].each do |type|
               encrypted_value = type.serialize(value)
@@ -21,7 +21,6 @@ module ActiveRecord
               end
             end
           end
-          end
         end
       end
     end

data/lib/active_record/encryption/message_serializer.rb

@@ -33,10 +33,20 @@ module ActiveRecord
 
       private
         def parse_message(data, level)
-          raise ActiveRecord::Encryption::Errors::Decryption, "More than one level of hash nesting in headers is not supported" if level > 2
+          validate_message_data_format(data, level)
           ActiveRecord::Encryption::Message.new(payload: decode_if_needed(data["p"]), headers: parse_properties(data["h"], level))
         end
 
+        def validate_message_data_format(data, level)
+          if level > 2
+            raise ActiveRecord::Encryption::Errors::Decryption, "More than one level of hash nesting in headers is not supported"
+          end
+
+          unless data.is_a?(Hash) && data.has_key?("p")
+            raise ActiveRecord::Encryption::Errors::Decryption, "Invalid data format: hash without payload"
+          end
+        end
+
         def parse_properties(headers, level)
           ActiveRecord::Encryption::Properties.new.tap do |properties|
             headers&.each do |key, value|

data/lib/active_record/encryption/scheme.rb

@@ -82,7 +82,7 @@ module ActiveRecord
 
         def validate_credential(key, error_message = "is not configured")
           unless ActiveRecord::Encryption.config.public_send(key).present?
-            raise Errors::Configuration, "#{key} #{error_message}. Please configure it via credential"\
+            raise Errors::Configuration, "#{key} #{error_message}. Please configure it via credential "\
               "active_record_encryption.#{key} or by setting config.active_record.encryption.#{key}"
           end
         end

data/lib/active_record/enum.rb

@@ -57,13 +57,20 @@ module ActiveRecord
   #   conversation = Conversation.new
   #   conversation.status # => "active"
   #
-  # Finally, it's also possible to explicitly map the relation between attribute and
+  # It's possible to explicitly map the relation between attribute and
   # database integer with a hash:
   #
   #   class Conversation < ActiveRecord::Base
   #     enum :status, active: 0, archived: 1
   #   end
   #
+  # Finally it's also possible to use a string column to persist the enumerated value.
+  # Note that this will likely lead to slower database queries:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, active: "active", archived: "archived"
+  #   end
+  #
   # Note that when an array is used, the implicit mapping from the values to database
   # integers is derived from the order the values appear in the array. In the example,
   # <tt>:active</tt> is mapped to +0+ as it's the first element, and <tt>:archived</tt>

data/lib/active_record/errors.rb

@@ -326,7 +326,7 @@ module ActiveRecord
   #           # The system must fail on Friday so that our support department
   #           # won't be out of job. We silently rollback this transaction
   #           # without telling the user.
-  #           raise ActiveRecord::Rollback, "Call tech support!"
+  #           raise ActiveRecord::Rollback
   #         end
   #       end
   #       # ActiveRecord::Rollback is the only exception that won't be passed on

data/lib/active_record/explain_registry.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/per_thread_registry"
+require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
   # This is a thread locals registry for EXPLAIN. For example
@@ -8,13 +8,18 @@ module ActiveRecord
   #   ActiveRecord::ExplainRegistry.queries
   #
   # returns the collected queries local to the current thread.
-  #
-  # See the documentation of ActiveSupport::PerThreadRegistry
-  # for further details.
   class ExplainRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
+    class << self
+      delegate :reset, :collect, :collect=, :collect?, :queries, to: :instance
+
+      private
+        def instance
+          ActiveSupport::IsolatedExecutionState[:active_record_explain_registry] ||= new
+        end
+    end
 
-    attr_accessor :queries, :collect
+    attr_accessor :collect
+    attr_reader :queries
 
     def initialize
       reset

data/lib/active_record/fixture_set/table_row.rb

@@ -126,7 +126,7 @@ module ActiveRecord
         end
 
         def resolve_enums
-          model_class.defined_enums.each do |name, values|
+          reflection_class.defined_enums.each do |name, values|
             if @row.include?(name)
               @row[name] = values.fetch(@row[name], @row[name])
             end

data/lib/active_record/fixtures.rb

@@ -407,7 +407,7 @@ module ActiveRecord
   # defaults:
   #
   #   DEFAULTS: &DEFAULTS
-  #     created_on: <%= 3.weeks.ago.to_s(:db) %>
+  #     created_on: <%= 3.weeks.ago.to_formatted_s(:db) %>
   #
   #   first:
   #     name: Smurf
@@ -585,14 +585,6 @@ module ActiveRecord
         end
       end
 
-      def signed_global_id(fixture_set_name, label, column_type: :integer, **options)
-        identifier = identify(label, column_type)
-        model_name = default_fixture_model_name(fixture_set_name)
-        uri = URI::GID.build([GlobalID.app, model_name, identifier, {}])
-
-        SignedGlobalID.new(uri, **options)
-      end
-
       # Superclass for the evaluation contexts used by ERB fixtures.
       def context_class
         @context_class ||= Class.new

data/lib/active_record/future_result.rb

@@ -102,12 +102,12 @@ module ActiveRecord
 
       def execute_or_wait
         if pending?
-          start = Concurrent.monotonic_time
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
           @mutex.synchronize do
             if pending?
               execute_query(@pool.connection)
             else
-              @lock_wait = (Concurrent.monotonic_time - start) * 1_000
+              @lock_wait = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start)
             end
           end
         else

data/lib/active_record/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     MAJOR = 7
     MINOR = 0
     TINY  = 0
-    PRE   = "alpha2"
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/insert_all.rb

@@ -5,21 +5,19 @@ require "active_support/core_ext/enumerable"
 module ActiveRecord
   class InsertAll # :nodoc:
     attr_reader :model, :connection, :inserts, :keys
-    attr_reader :on_duplicate, :returning, :unique_by, :update_sql
+    attr_reader :on_duplicate, :update_only, :returning, :unique_by, :update_sql
 
-    def initialize(model, inserts, on_duplicate:, returning: nil, unique_by: nil)
+    def initialize(model, inserts, on_duplicate:, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
       raise ArgumentError, "Empty list of attributes passed" if inserts.blank?
 
       @model, @connection, @inserts, @keys = model, model.connection, inserts, inserts.first.keys.map(&:to_s)
-      @on_duplicate, @returning, @unique_by = on_duplicate, returning, unique_by
+      @on_duplicate, @update_only, @returning, @unique_by = on_duplicate, update_only, returning, unique_by
+      @record_timestamps = record_timestamps.nil? ? model.record_timestamps : record_timestamps
 
-      disallow_raw_sql!(returning)
       disallow_raw_sql!(on_duplicate)
+      disallow_raw_sql!(returning)
 
-      if Arel.arel_node?(on_duplicate)
-        @update_sql = on_duplicate
-        @on_duplicate = :update
-      end
+      configure_on_duplicate_update_logic
 
       if model.scope_attributes?
         @scope_attributes = model.scope_attributes
@@ -44,7 +42,7 @@ module ActiveRecord
     end
 
     def updatable_columns
-      keys - readonly_columns - unique_by_columns
+      @updatable_columns ||= keys - readonly_columns - unique_by_columns
     end
 
     def primary_keys
@@ -64,18 +62,50 @@ module ActiveRecord
       inserts.map do |attributes|
         attributes = attributes.stringify_keys
         attributes.merge!(scope_attributes) if scope_attributes
+        attributes.reverse_merge!(timestamps_for_create) if record_timestamps?
 
         verify_attributes(attributes)
 
-        keys.map do |key|
+        keys_including_timestamps.map do |key|
           yield key, attributes[key]
         end
       end
     end
 
+    def record_timestamps?
+      @record_timestamps
+    end
+
+    # TODO: Consider remaining this method, as it only conditionally extends keys, not always
+    def keys_including_timestamps
+      @keys_including_timestamps ||= if record_timestamps?
+        keys + model.all_timestamp_attributes_in_model
+      else
+        keys
+      end
+    end
+
     private
       attr_reader :scope_attributes
 
+      def configure_on_duplicate_update_logic
+        if custom_update_sql_provided? && update_only.present?
+          raise ArgumentError, "You can't set :update_only and provide custom update SQL via :on_duplicate at the same time"
+        end
+
+        if update_only.present?
+          @updatable_columns = Array(update_only)
+          @on_duplicate = :update
+        elsif custom_update_sql_provided?
+          @update_sql = on_duplicate
+          @on_duplicate = :update
+        end
+      end
+
+      def custom_update_sql_provided?
+        @custom_update_sql_provided ||= Arel.arel_node?(on_duplicate)
+      end
+
       def find_unique_index_for(unique_by)
         if !connection.supports_insert_conflict_target?
           return if unique_by.nil?
@@ -134,7 +164,7 @@ module ActiveRecord
 
 
       def verify_attributes(attributes)
-        if keys != attributes.keys.to_set
+        if keys_including_timestamps != attributes.keys.to_set
           raise ArgumentError, "All objects being inserted must have the same keys"
         end
       end
@@ -148,10 +178,14 @@ module ActiveRecord
                              "by wrapping them in Arel.sql()."
       end
 
+      def timestamps_for_create
+        model.all_timestamp_attributes_in_model.index_with(connection.high_precision_current_timestamp)
+      end
+
       class Builder # :nodoc:
         attr_reader :model
 
-        delegate :skip_duplicates?, :update_duplicates?, :keys, to: :insert_all
+        delegate :skip_duplicates?, :update_duplicates?, :keys, :keys_including_timestamps, :record_timestamps?, to: :insert_all
 
         def initialize(insert_all)
           @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
@@ -162,9 +196,10 @@ module ActiveRecord
         end
 
         def values_list
-          types = extract_types_from_columns_on(model.table_name, keys: keys)
+          types = extract_types_from_columns_on(model.table_name, keys: keys_including_timestamps)
 
           values_list = insert_all.map_key_with_value do |key, value|
+            next value if Arel::Nodes::SqlLiteral === value
             connection.with_yaml_fallback(types[key].serialize(value))
           end
 
@@ -196,6 +231,8 @@ module ActiveRecord
         end
 
         def touch_model_timestamps_unless(&block)
+          return "" unless update_duplicates? && record_timestamps?
+
           model.timestamp_attributes_for_update_in_model.filter_map do |column_name|
             if touch_timestamp_attribute?(column_name)
               "#{column_name}=(CASE WHEN (#{updatable_columns.map(&block).join(" AND ")}) THEN #{model.quoted_table_name}.#{column_name} ELSE #{connection.high_precision_current_timestamp} END),"
@@ -213,11 +250,11 @@ module ActiveRecord
           attr_reader :connection, :insert_all
 
           def touch_timestamp_attribute?(column_name)
-            update_duplicates? && !insert_all.updatable_columns.include?(column_name)
+            insert_all.updatable_columns.exclude?(column_name)
           end
 
           def columns_list
-            format_columns(insert_all.keys)
+            format_columns(insert_all.keys_including_timestamps)
           end
 
           def extract_types_from_columns_on(table_name, keys:)

data/lib/active_record/integration.rb

@@ -79,7 +79,7 @@ module ActiveRecord
           timestamp = max_updated_column_timestamp
 
           if timestamp
-            timestamp = timestamp.utc.to_s(cache_timestamp_format)
+            timestamp = timestamp.utc.to_formatted_s(cache_timestamp_format)
             "#{model_name.cache_key}/#{id}-#{timestamp}"
           else
             "#{model_name.cache_key}/#{id}"
@@ -101,8 +101,9 @@ module ActiveRecord
         timestamp = updated_at_before_type_cast
         if can_use_fast_cache_version?(timestamp)
           raw_timestamp_to_cache_version(timestamp)
+
         elsif timestamp = updated_at
-          timestamp.utc.to_s(cache_timestamp_format)
+          timestamp.utc.to_formatted_s(cache_timestamp_format)
         end
       elsif self.class.has_attribute?("updated_at")
         raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"

data/lib/active_record/legacy_yaml_adapter.rb

@@ -2,50 +2,13 @@
 
 module ActiveRecord
   module LegacyYamlAdapter # :nodoc:
-    def self.convert(klass, coder)
+    def self.convert(coder)
       return coder unless coder.is_a?(Psych::Coder)
 
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          YAML loading from legacy format older than Rails 5.0 is deprecated
-          and will be removed in Rails 7.0.
-        MSG
-        if coder["attributes"].is_a?(ActiveModel::AttributeSet)
-          Rails420.convert(klass, coder)
-        else
-          Rails41.convert(klass, coder)
-        end
-      end
-    end
-
-    module Rails420 # :nodoc:
-      def self.convert(klass, coder)
-        attribute_set = coder["attributes"]
-
-        klass.attribute_names.each do |attr_name|
-          attribute = attribute_set[attr_name]
-          if attribute.type.is_a?(Delegator)
-            type_from_klass = klass.type_for_attribute(attr_name)
-            attribute_set[attr_name] = attribute.with_type(type_from_klass)
-          end
-        end
-
-        coder
-      end
-    end
-
-    module Rails41 # :nodoc:
-      def self.convert(klass, coder)
-        attributes = klass.attributes_builder
-          .build_from_database(coder["attributes"])
-        new_record = coder["attributes"][klass.primary_key].blank?
-
-        {
-          "attributes" => attributes,
-          "new_record" => new_record,
-        }
+        raise("Active Record doesn't know how to load YAML with this format.")
       end
     end
   end

data/lib/active_record/locking/pessimistic.rb

@@ -81,9 +81,15 @@ module ActiveRecord
 
       # Wraps the passed block in a transaction, locking the object
       # before yielding. You can pass the SQL locking clause
-      # as argument (see <tt>lock!</tt>).
-      def with_lock(lock = true)
-        transaction do
+      # as an optional argument (see <tt>#lock!</tt>).
+      #
+      # You can also pass options like <tt>requires_new:</tt>, <tt>isolation:</tt>,
+      # and <tt>joinable:</tt> to the wrapping transaction (see
+      # <tt>ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction</tt>).
+      def with_lock(*args)
+        transaction_opts = args.extract_options!
+        lock = args.present? ? args.first : true
+        transaction(**transaction_opts) do
           lock!(lock)
           yield
         end

data/lib/active_record/log_subscriber.rb

@@ -51,7 +51,10 @@ module ActiveRecord
 
         binds = []
         payload[:binds].each_with_index do |attr, i|
-          binds << render_bind(attr, casted_params[i])
+          attribute_name = attr.respond_to?(:name) ? attr.name : attr[i].name
+          filtered_params = filter(attribute_name, casted_params[i])
+
+          binds << render_bind(attr, filtered_params)
         end
         binds = binds.inspect
         binds.prepend("  ")
@@ -135,6 +138,10 @@ module ActiveRecord
       def extract_query_source_location(locations)
         backtrace_cleaner.clean(locations.lazy).first
       end
+
+      def filter(name, value)
+        ActiveRecord::Base.inspection_filter.filter_param(name, value)
+      end
   end
 end
 

data/lib/active_record/middleware/shard_selector.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Middleware
+    # The ShardSelector Middleware provides a framework for automatically
+    # swapping shards. Rails provides a basic framework to determine which
+    # shard to switch to and allows for applications to write custom strategies
+    # for swapping if needed.
+    #
+    # The ShardSelector takes a set of options (currently only `lock` is supported)
+    # that can be used by the middleware to alter behavior. `lock` is
+    # true by default and will prohibit the request from switching shards once
+    # inside the block. If `lock` is false, then shard swapping will be allowed.
+    # For tenant based sharding, `lock` should always be true to prevent application
+    # code from mistakenly switching between tenants.
+    #
+    # Options can be set in the config:
+    #
+    #   config.active_record.shard_selector = { lock: true }
+    #
+    # Applications must also provide the code for the resolver as it depends on application
+    # specific models. An example resolver would look like this:
+    #
+    #   config.active_record.shard_resolver = ->(request) {
+    #     subdomain = request.subdomain
+    #     tenant = Tenant.find_by_subdomain!(subdomain)
+    #     tenant.shard
+    #   }
+    class ShardSelector
+      def initialize(app, resolver, options = {})
+        @app = app
+        @resolver = resolver
+        @options = options
+      end
+
+      attr_reader :resolver, :options
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        shard = selected_shard(request)
+
+        set_shard(shard) do
+          @app.call(env)
+        end
+      end
+
+      private
+        def selected_shard(request)
+          resolver.call(request)
+        end
+
+        def set_shard(shard, &block)
+          ActiveRecord::Base.connected_to(shard: shard.to_sym) do
+            ActiveRecord::Base.prohibit_shard_swapping(options.fetch(:lock, true), &block)
+          end
+        end
+    end
+  end
+end