activerecord 7.1.0.beta1 → 7.1.0.rc2

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -126,6 +126,7 @@ module ActiveRecord
 
         @config[:strict] = ConnectionAdapters::SQLite3Adapter.strict_strings_by_default unless @config.key?(:strict)
         @connection_parameters = @config.merge(database: @config[:database].to_s, results_as_hash: true)
+        @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
       end
 
       def database_exists?
@@ -180,6 +181,10 @@ module ActiveRecord
         database_version >= "3.8.3"
       end
 
+      def supports_insert_returning?
+        database_version >= "3.35.0"
+      end
+
       def supports_insert_on_conflict?
         database_version >= "3.24.0"
       end
@@ -195,6 +200,10 @@ module ActiveRecord
         @raw_connection && !@raw_connection.closed?
       end
 
+      def return_value_after_insert?(column) # :nodoc:
+        column.auto_populated?
+      end
+
       alias :reset! :reconnect!
 
       # Disconnects from the database if already connected. Otherwise, this
@@ -393,6 +402,7 @@ module ActiveRecord
           end
         end
 
+        sql << " RETURNING #{insert.returning}" if insert.returning
         sql
       end
 
@@ -400,6 +410,10 @@ module ActiveRecord
         @config.fetch(:flags, 0).anybits?(::SQLite3::Constants::Open::SHAREDCACHE)
       end
 
+      def use_insert_returning?
+        @use_insert_returning
+      end
+
       def get_database_version # :nodoc:
         SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)", "SCHEMA"))
       end
@@ -451,10 +465,10 @@ module ActiveRecord
           when /^null$/i
             nil
           # Quoted types
-          when /^'(.*)'$/m
+          when /^'([^|]*)'$/m
             $1.gsub("''", "'")
           # Quoted types
-          when /^"(.*)"$/m
+          when /^"([^|]*)"$/m
             $1.gsub('""', '"')
           # Numeric types
           when /\A-?\d+(\.\d*)?\z/
@@ -474,7 +488,7 @@ module ActiveRecord
         end
 
         def has_default_function?(default_value, default)
-          !default_value && %r{\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+          !default_value && %r{\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP|\|\|}.match?(default)
         end
 
         # See: https://www.sqlite.org/lang_altertable.html
@@ -698,9 +712,40 @@ module ActiveRecord
         end
 
         def configure_connection
-          @raw_connection.busy_timeout(self.class.type_cast_config_to_integer(@config[:timeout])) if @config[:timeout]
+          if @config[:timeout] && @config[:retries]
+            raise ArgumentError, "Cannot specify both timeout and retries arguments"
+          elsif @config[:timeout]
+            @raw_connection.busy_timeout(self.class.type_cast_config_to_integer(@config[:timeout]))
+          elsif @config[:retries]
+            retries = self.class.type_cast_config_to_integer(@config[:retries])
+            raw_connection.busy_handler do |count|
+              count <= retries
+            end
+          end
 
+          # Enforce foreign key constraints
+          # https://www.sqlite.org/pragma.html#pragma_foreign_keys
+          # https://www.sqlite.org/foreignkeys.html
           raw_execute("PRAGMA foreign_keys = ON", "SCHEMA")
+          unless @memory_database
+            # Journal mode WAL allows for greater concurrency (many readers + one writer)
+            # https://www.sqlite.org/pragma.html#pragma_journal_mode
+            raw_execute("PRAGMA journal_mode = WAL", "SCHEMA")
+            # Set more relaxed level of database durability
+            # 2 = "FULL" (sync on every write), 1 = "NORMAL" (sync every 1000 written pages) and 0 = "NONE"
+            # https://www.sqlite.org/pragma.html#pragma_synchronous
+            raw_execute("PRAGMA synchronous = NORMAL", "SCHEMA")
+            # Set the global memory map so all processes can share some data
+            # https://www.sqlite.org/pragma.html#pragma_mmap_size
+            # https://www.sqlite.org/mmap.html
+            raw_execute("PRAGMA mmap_size = #{128.megabytes}", "SCHEMA")
+          end
+          # Impose a limit on the WAL file to prevent unlimited growth
+          # https://www.sqlite.org/pragma.html#pragma_journal_size_limit
+          raw_execute("PRAGMA journal_size_limit = #{64.megabytes}", "SCHEMA")
+          # Set the local connection cache to 2000 pages
+          # https://www.sqlite.org/pragma.html#pragma_cache_size
+          raw_execute("PRAGMA cache_size = 2000", "SCHEMA")
         end
     end
     ActiveSupport.run_load_hooks(:active_record_sqlite3adapter, SQLite3Adapter)

data/lib/active_record/core.rb

@@ -344,11 +344,6 @@ module ActiveRecord
         end
       end
 
-      # Override the default class equality method to provide support for decorated models.
-      def ===(object) # :nodoc:
-        object.is_a?(self)
-      end
-
       # Returns an instance of +Arel::Table+ loaded with the current table name.
       def arel_table # :nodoc:
         @arel_table ||= Arel::Table.new(table_name, klass: self)
@@ -615,7 +610,9 @@ module ActiveRecord
     #
     #   user = User.first
     #   user.strict_loading! # => true
-    #   user.comments
+    #   user.address.city
+    #   => ActiveRecord::StrictLoadingViolationError
+    #   user.comments.to_a
     #   => ActiveRecord::StrictLoadingViolationError
     #
     # ==== Parameters
@@ -629,12 +626,13 @@ module ActiveRecord
     #
     #   user = User.first
     #   user.strict_loading!(false) # => false
-    #   user.comments
-    #   => #<ActiveRecord::Associations::CollectionProxy>
+    #   user.address.city # => "Tatooine"
+    #   user.comments.to_a # => [#<Comment:0x00...]
     #
     #   user.strict_loading!(mode: :n_plus_one_only)
     #   user.address.city # => "Tatooine"
-    #   user.comments
+    #   user.comments.to_a # => [#<Comment:0x00...]
+    #   user.comments.first.ratings.to_a
     #   => ActiveRecord::StrictLoadingViolationError
     def strict_loading!(value = true, mode: :all)
       unless [:all, :n_plus_one_only].include?(mode)

data/lib/active_record/encryption/extended_deterministic_uniqueness_validator.rb

@@ -14,7 +14,7 @@ module ActiveRecord
           klass = record.class
           if klass.deterministic_encrypted_attributes&.include?(attribute)
             encrypted_type = klass.type_for_attribute(attribute)
-            [ encrypted_type, *encrypted_type.previous_types ].each do |type|
+            encrypted_type.previous_types.each do |type|
               encrypted_value = type.serialize(value)
               ActiveRecord::Encryption.without_encryption do
                 super(record, attribute, encrypted_value)

data/lib/active_record/errors.rb

@@ -483,6 +483,19 @@ module ActiveRecord
   # TransactionRollbackError will be raised when a transaction is rolled
   # back by the database due to a serialization failure or a deadlock.
   #
+  # These exceptions should not be generally rescued in nested transaction
+  # blocks, because they have side-effects in the actual enclosing transaction
+  # and internal Active Record state. They can be rescued if you are above the
+  # root transaction block, though.
+  #
+  # In that case, beware of transactional tests, however, because they run test
+  # cases in their own umbrella transaction. If you absolutely need to handle
+  # these exceptions in tests please consider disabling transactional tests in
+  # the affected test class (<tt>self.use_transactional_tests = false</tt>).
+  #
+  # Due to the aforementioned side-effects, this exception should not be raised
+  # manually by users.
+  #
   # See the following:
   #
   # * https://www.postgresql.org/docs/current/static/transaction-iso.html
@@ -497,11 +510,17 @@ module ActiveRecord
 
   # SerializationFailure will be raised when a transaction is rolled
   # back by the database due to a serialization failure.
+  #
+  # This is a subclass of TransactionRollbackError, please make sure to check
+  # its documentation to be aware of its caveats.
   class SerializationFailure < TransactionRollbackError
   end
 
   # Deadlocked will be raised when a transaction is rolled
   # back by the database when a deadlock is encountered.
+  #
+  # This is a subclass of TransactionRollbackError, please make sure to check
+  # its documentation to be aware of its caveats.
   class Deadlocked < TransactionRollbackError
   end
 

data/lib/active_record/gem_version.rb

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

data/lib/active_record/migration/command_recorder.rb

@@ -12,7 +12,7 @@ module ActiveRecord
     # * add_foreign_key
     # * add_check_constraint
     # * add_exclusion_constraint
-    # * add_unique_key
+    # * add_unique_constraint
     # * add_index
     # * add_reference
     # * add_timestamps
@@ -33,7 +33,7 @@ module ActiveRecord
     # * remove_foreign_key (must supply a second table)
     # * remove_check_constraint
     # * remove_exclusion_constraint
-    # * remove_unique_key
+    # * remove_unique_constraint
     # * remove_index
     # * remove_reference
     # * remove_timestamps
@@ -53,7 +53,7 @@ module ActiveRecord
         :change_column_comment, :change_table_comment,
         :add_check_constraint, :remove_check_constraint,
         :add_exclusion_constraint, :remove_exclusion_constraint,
-        :add_unique_key, :remove_unique_key,
+        :add_unique_constraint, :remove_unique_constraint,
         :create_enum, :drop_enum, :rename_enum, :add_enum_value, :rename_enum_value,
       ]
       include JoinTable
@@ -161,7 +161,7 @@ module ActiveRecord
               add_foreign_key:   :remove_foreign_key,
               add_check_constraint: :remove_check_constraint,
               add_exclusion_constraint: :remove_exclusion_constraint,
-              add_unique_key: :remove_unique_key,
+              add_unique_constraint: :remove_unique_constraint,
               enable_extension:  :disable_extension,
               create_enum:       :drop_enum
             }.each do |cmd, inv|
@@ -329,17 +329,17 @@ module ActiveRecord
           super
         end
 
-        def invert_add_unique_key(args)
+        def invert_add_unique_constraint(args)
           options = args.dup.extract_options!
 
-          raise ActiveRecord::IrreversibleMigration, "add_unique_key is not reversible if given an using_index." if options[:using_index]
+          raise ActiveRecord::IrreversibleMigration, "add_unique_constraint is not reversible if given an using_index." if options[:using_index]
           super
         end
 
-        def invert_remove_unique_key(args)
+        def invert_remove_unique_constraint(args)
           _table, columns = args.dup.tap(&:extract_options!)
 
-          raise ActiveRecord::IrreversibleMigration, "remove_unique_key is only reversible if given an column_name." if columns.blank?
+          raise ActiveRecord::IrreversibleMigration, "remove_unique_constraint is only reversible if given an column_name." if columns.blank?
           super
         end
 

data/lib/active_record/nested_attributes.rb

@@ -355,17 +355,12 @@ module ActiveRecord
         options.update(attr_names.extract_options!)
         options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
         options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
-        options[:class] = self
 
         attr_names.each do |association_name|
           if reflection = _reflect_on_association(association_name)
             reflection.autosave = true
             define_autosave_validation_callbacks(reflection)
 
-            if nested_attributes_options.dig(association_name.to_sym, :class) == self
-              raise ArgumentError, "Already declared #{association_name} as an accepts_nested_attributes association for this class."
-            end
-
             nested_attributes_options = self.nested_attributes_options.dup
             nested_attributes_options[association_name.to_sym] = options
             self.nested_attributes_options = nested_attributes_options

data/lib/active_record/normalization.rb

@@ -51,7 +51,8 @@ module ActiveRecord # :nodoc:
       #
       # ==== Options
       #
-      # * +:with+ - The normalization to apply.
+      # * +:with+ - Any callable object that accepts the attribute's value as
+      #   its sole argument, and returns it normalized.
       # * +:apply_to_nil+ - Whether to apply the normalization to +nil+ values.
       #   Defaults to +false+.
       #

data/lib/active_record/persistence.rb

@@ -1272,7 +1272,7 @@ module ActiveRecord
     def _raise_record_not_destroyed
       @_association_destroy_exception ||= nil
       key = self.class.primary_key
-      raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{send(key)}", self)
+      raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{id}", self)
     ensure
       @_association_destroy_exception = nil
     end

data/lib/active_record/querying.rb

@@ -51,7 +51,7 @@ module ActiveRecord
       _load_from_sql(_query_by_sql(sql, binds, preparable: preparable), &block)
     end
 
-    # Same as <tt>#find_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#find_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_find_by_sql(sql, binds = [], preparable: nil, &block)
       _query_by_sql(sql, binds, preparable: preparable, async: true).then do |result|
         _load_from_sql(result, &block)
@@ -102,7 +102,7 @@ module ActiveRecord
       connection.select_value(sanitize_sql(sql), "#{name} Count").to_i
     end
 
-    # Same as <tt>#count_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#count_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_count_by_sql(sql)
       connection.select_value(sanitize_sql(sql), "#{name} Count", async: true).then(&:to_i)
     end

data/lib/active_record/railtie.rb

@@ -67,7 +67,7 @@ module ActiveRecord
       unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
         console = ActiveSupport::Logger.new(STDERR)
         console.level = Rails.logger.level
-        Rails.logger.extend ActiveSupport::Logger.broadcast console
+        Rails.logger.broadcast_to(console)
       end
       ActiveRecord.verbose_query_logs = false
     end

data/lib/active_record/reflection.rb

@@ -507,7 +507,7 @@ module ActiveRecord
           derived_fk = derive_foreign_key(infer_from_inverse_of: infer_from_inverse_of)
 
           if active_record.has_query_constraints?
-            derived_fk = derive_fk_query_constraints(active_record, derived_fk)
+            derived_fk = derive_fk_query_constraints(derived_fk)
           end
 
           derived_fk
@@ -770,13 +770,13 @@ module ActiveRecord
           end
         end
 
-        def derive_fk_query_constraints(klass, foreign_key)
-          primary_query_constraints = klass.query_constraints_list
-          owner_pk = klass.primary_key
+        def derive_fk_query_constraints(foreign_key)
+          primary_query_constraints = active_record.query_constraints_list
+          owner_pk = active_record.primary_key
 
           if primary_query_constraints.size != 2
             raise ArgumentError, <<~MSG.squish
-              The query constraints list on the `#{klass}` model has more than 2
+              The query constraints list on the `#{active_record}` model has more than 2
               attributes. Active Record is unable to derive the query constraints
               for the association. You need to explicitly define the query constraints
               for this association.
@@ -785,19 +785,13 @@ module ActiveRecord
 
           if !primary_query_constraints.include?(owner_pk)
             raise ArgumentError, <<~MSG.squish
-              The query constraints on the `#{klass}` model does not include the primary
+              The query constraints on the `#{active_record}` model does not include the primary
               key so Active Record is unable to derive the foreign key constraints for
               the association. You need to explicitly define the query constraints for this
               association.
             MSG
           end
 
-          # The primary key and foreign key are both already in the query constraints
-          # so we don't want to derive the key. In this case we want a single key.
-          if primary_query_constraints.include?(owner_pk) && primary_query_constraints.include?(foreign_key)
-            return foreign_key
-          end
-
           first_key, last_key = primary_query_constraints
 
           if first_key == owner_pk
@@ -807,7 +801,7 @@ module ActiveRecord
           else
             raise ArgumentError, <<~MSG.squish
               Active Record couldn't correctly interpret the query constraints
-              for the `#{klass}` model. The query constraints on `#{klass}` are
+              for the `#{active_record}` model. The query constraints on `#{active_record}` are
               `#{primary_query_constraints}` and the foreign key is `#{foreign_key}`.
               You need to explicitly set the query constraints for this association.
             MSG
@@ -862,10 +856,10 @@ module ActiveRecord
 
       # klass option is necessary to support loading polymorphic associations
       def association_primary_key(klass = nil)
-        if !polymorphic? && ((klass || self.klass).has_query_constraints? || options[:query_constraints])
-          (klass || self.klass).composite_query_constraints_list
-        elsif primary_key = options[:primary_key]
+        if primary_key = options[:primary_key]
           @association_primary_key ||= -primary_key.to_s
+        elsif !polymorphic? && ((klass || self.klass).has_query_constraints? || options[:query_constraints])
+          (klass || self.klass).composite_query_constraints_list
         elsif (klass || self.klass).composite_primary_key?
           # If klass has composite primary key of shape [:<tenant_key>, :id], infer primary_key as :id
           primary_key = (klass || self.klass).primary_key

data/lib/active_record/relation/calculations.rb

@@ -93,7 +93,7 @@ module ActiveRecord
       end
     end
 
-    # Same as <tt>#count</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#count</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_count(column_name = nil)
       async.count(column_name)
     end
@@ -106,7 +106,7 @@ module ActiveRecord
       calculate(:average, column_name)
     end
 
-    # Same as <tt>#average</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#average</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_average(column_name)
       async.average(column_name)
     end
@@ -120,7 +120,7 @@ module ActiveRecord
       calculate(:minimum, column_name)
     end
 
-    # Same as <tt>#minimum</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#minimum</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_minimum(column_name)
       async.minimum(column_name)
     end
@@ -134,7 +134,7 @@ module ActiveRecord
       calculate(:maximum, column_name)
     end
 
-    # Same as <tt>#maximum</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#maximum</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_maximum(column_name)
       async.maximum(column_name)
     end
@@ -152,7 +152,7 @@ module ActiveRecord
       end
     end
 
-    # Same as <tt>#sum</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#sum</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_sum(identity_or_column = nil)
       async.sum(identity_or_column)
     end
@@ -287,7 +287,7 @@ module ActiveRecord
       end
     end
 
-    # Same as <tt>#pluck</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#pluck</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_pluck(*column_names)
       async.pluck(*column_names)
     end
@@ -315,7 +315,7 @@ module ActiveRecord
       limit(1).pluck(*column_names).then(&:first)
     end
 
-    # Same as <tt>#pick</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#pick</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_pick(*column_names)
       async.pick(*column_names)
     end
@@ -358,7 +358,7 @@ module ActiveRecord
       result.then { |result| type_cast_pluck_values(result, columns) }
     end
 
-    # Same as <tt>#ids</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    # Same as <tt>#ids</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_ids
       async.ids
     end

data/lib/active_record/relation/finder_methods.rb

@@ -16,7 +16,7 @@ module ActiveRecord
     #   Person.find("1")        # returns the object for ID = 1
     #   Person.find("31-sarah") # returns the object for ID = 31
     #   Person.find(1, 2, 6)    # returns an array for objects with IDs in (1, 2, 6)
-    #   Person.find([7, 17])    # returns an array for objects with IDs in (7, 17)
+    #   Person.find([7, 17])    # returns an array for objects with IDs in (7, 17), or with composite primary key [7, 17]
     #   Person.find([1])        # returns an array for the object with ID = 1
     #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
@@ -527,12 +527,7 @@ module ActiveRecord
       def find_some(ids)
         return find_some_ordered(ids) unless order_values.present?
 
-        relation = if klass.composite_primary_key?
-          ids.map { |values_set| where(primary_key.zip(values_set).to_h) }.inject(&:or)
-        else
-          where(primary_key => ids)
-        end
-
+        relation = where(primary_key => ids)
         relation = relation.select(table[primary_key]) unless select_values.empty?
         result = relation.to_a
 
@@ -559,11 +554,7 @@ module ActiveRecord
         ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
 
         relation = except(:limit, :offset)
-        relation = if klass.composite_primary_key?
-          ids.map { |values_set| relation.where(primary_key.zip(values_set).to_h) }.inject(&:or)
-        else
-          relation.where(primary_key => ids)
-        end
+        relation = relation.where(primary_key => ids)
         relation = relation.select(table[primary_key]) unless select_values.empty?
         result = relation.records
 

data/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb

@@ -34,19 +34,17 @@ module ActiveRecord
         end
 
         def klass(value)
-          case value
-          when Base
+          if value.is_a?(Base)
             value.class
-          when Relation
+          elsif value.is_a?(Relation)
             value.klass
           end
         end
 
         def convert_to_id(value)
-          case value
-          when Base
+          if value.is_a?(Base)
             value._read_attribute(primary_key(value))
-          when Relation
+          elsif value.is_a?(Relation)
             value.select(primary_key(value))
           else
             value

data/lib/active_record/schema_dumper.rb

@@ -57,6 +57,7 @@ module ActiveRecord
 
     def dump(stream)
       header(stream)
+      schemas(stream)
       extensions(stream)
       types(stream)
       tables(stream)
@@ -119,6 +120,10 @@ module ActiveRecord
       def types(stream)
       end
 
+      # schemas are only supported by PostgreSQL
+      def schemas(stream)
+      end
+
       def tables(stream)
         sorted_tables = @connection.tables.sort
 
@@ -188,7 +193,7 @@ module ActiveRecord
           indexes_in_create(table, tbl)
           check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
           exclusion_constraints_in_create(table, tbl) if @connection.supports_exclusion_constraints?
-          unique_keys_in_create(table, tbl) if @connection.supports_unique_keys?
+          unique_constraints_in_create(table, tbl) if @connection.supports_unique_constraints?
 
           tbl.puts "  end"
           tbl.puts
@@ -224,10 +229,10 @@ module ActiveRecord
             indexes = indexes.reject { |index| exclusion_constraint_names.include?(index.name) }
           end
 
-          if @connection.supports_unique_keys? && (unique_keys = @connection.unique_keys(table)).any?
-            unique_key_names = unique_keys.collect(&:name)
+          if @connection.supports_unique_constraints? && (unique_constraints = @connection.unique_constraints(table)).any?
+            unique_constraint_names = unique_constraints.collect(&:name)
 
-            indexes = indexes.reject { |index| unique_key_names.include?(index.name) }
+            indexes = indexes.reject { |index| unique_constraint_names.include?(index.name) }
           end
 
           index_statements = indexes.map do |index|

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -23,6 +23,7 @@ module ActiveRecord
         db_path = db_config.database
         file = File.absolute_path?(db_path) ? db_path : File.join(root, db_path)
         FileUtils.rm(file)
+        FileUtils.rm_f(["#{file}-shm", "#{file}-wal"])
       rescue Errno::ENOENT => error
         raise NoDatabaseError.new(error.message)
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 7.1.0.beta1
+  version: 7.1.0.rc2
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-13 00:00:00.000000000 Z
+date: 2023-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.0.beta1
+        version: 7.1.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.0.beta1
+        version: 7.1.0.rc2
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.0.beta1
+        version: 7.1.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.0.beta1
+        version: 7.1.0.rc2
 - !ruby/object:Gem::Dependency
   name: timeout
   requirement: !ruby/object:Gem::Requirement
@@ -469,10 +469,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v7.1.0.beta1/activerecord/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v7.1.0.beta1/
+  changelog_uri: https://github.com/rails/rails/blob/v7.1.0.rc2/activerecord/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v7.1.0.rc2/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v7.1.0.beta1/activerecord
+  source_code_uri: https://github.com/rails/rails/tree/v7.1.0.rc2/activerecord
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: