activerecord 7.0.5 → 7.0.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3039efb205667bcd9fc218b22042ee4a8f36b735f62fedf208a56b70bb3bd5c
-  data.tar.gz: df54f94c2480c583f2236f31de29f55525ee8f281fea93b30690f57f775d758b
+  metadata.gz: d0dafed5cde1fc09899d9caea484b616eee6a654c8cdc2a4980900466a8e2ed5
+  data.tar.gz: 7a70971a3a00e75b2c1cce9c7e139a6eef609d0f3b650418ddf93c242e4539f0
 SHA512:
-  metadata.gz: a412b99cef7bb68b569f14be355f715f888f0072f33436d40ffe8e4c90c088539d0fd1d26d43e508d5e6a2089ad7a73874f1aef7094bc7dc5287bccca753496b
-  data.tar.gz: 4b6008f67510a941efad31e7cddc4f6af2a7149da4a68cb248ce5481631c674216204d0a0028686c36a8f61f4366b1b2c096c5a6fd8ea61d29884bc57822a0fe
+  metadata.gz: 770556493365d077a3bd6b825f2f1f68c7b2b124908ba8e5efd264d97f0ea7735c9594654017fb13d501d7e1818bf3a4d6e1435ce93e9081a39bae6f1d59851c
+  data.tar.gz: 30ddf2ad9e7eed26fe0ff9e453a7e201bd576ea0f0564dfded84333f4527e093f61b44fb02b2aedd4b2676354ba18e334ac17146b26ded1a6bbabda47d35221f

data/CHANGELOG.md

@@ -1,3 +1,217 @@
+## Rails 7.0.8.6 (October 23, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.0.8.5 (October 15, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.0.8.4 (June 04, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.0.8.3 (May 17, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.0.8.2 (May 16, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.0.8.1 (February 21, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.0.8 (September 09, 2023) ##
+
+*   Fix `change_column` not setting `precision: 6` on `datetime` columns when
+    using 7.0+ Migrations and SQLite.
+
+    *Hartley McGuire*
+
+*   Fix unscope is not working in specific case
+
+    Before:
+    ```ruby
+    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts` WHERE `posts`.`id` >= 1 AND `posts`.`id` < 3"
+
+    ```
+
+    After:
+    ```ruby
+    Post.where(id: 1...3).unscope(where: :id).to_sql # "SELECT `posts`.* FROM `posts`"
+    ```
+
+    Fixes #48094.
+
+    *Kazuya Hatanaka*
+
+*   Fix associations to a STI model including a `class_name` parameter
+
+    ```ruby
+    class Product < ApplicationRecord
+      has_many :requests, as: :requestable, class_name: "ProductRequest", dependent: :destroy
+    end
+
+    # STI tables
+    class Request < ApplicationRecord
+      belongs_to :requestable, polymorphic: true
+
+      validate :request_type, presence: true
+    end
+
+    class ProductRequest < Request
+      belongs_to :user
+    end
+    ```
+
+    Accessing such association would lead to:
+
+    ```
+    table_metadata.rb:22:in `has_column?': undefined method `key?' for nil:NilClass (NoMethodError)
+    ```
+
+    *Romain Filinto*
+
+*   Fix `change_table` setting datetime precision for 6.1 Migrations
+
+    *Hartley McGuire*
+
+*   Fix change_column setting datetime precision for 6.1 Migrations
+
+    *Hartley McGuire*
+
+## Rails 7.0.7.2 (August 22, 2023) ##
+
+*   No changes.
+
+
+## Rails 7.0.7.1 (August 22, 2023) ##
+
+*   No changes.
+
+
+## Rails 7.0.7 (August 09, 2023) ##
+
+*   Restores functionality to the missing method when using enums and fixes.
+
+    *paulreece*
+
+*   Fix `StatementCache::Substitute` with serialized type.
+
+    *ywenc*
+
+*   Fix `:db_runtime` on notification payload when application have multiple databases.
+
+    *Eileen M. Uchitelle*
+
+*   Correctly dump check constraints for MySQL 8.0.16+.
+
+    *Steve Hill*
+
+*   Fix `ActiveRecord::QueryMethods#in_order_of` to include `nil`s, to match the
+    behavior of `Enumerable#in_order_of`.
+
+    For example, `Post.in_order_of(:title, [nil, "foo"])` will now include posts
+    with `nil` titles, the same as `Post.all.to_a.in_order_of(:title, [nil, "foo"])`.
+
+    *fatkodima*
+
+*   Revert "Fix autosave associations with validations added on `:base` of the associated objects."
+
+    This change intended to remove the :base attribute from the message,
+    but broke many assumptions which key these errors were stored.
+
+    *zzak*
+
+*   Fix `#previously_new_record?` to return true for destroyed records.
+
+    Before, if a record was created and then destroyed, `#previously_new_record?` would return true.
+    Now, any UPDATE or DELETE to a record is considered a change, and will result in `#previously_new_record?`
+    returning false.
+
+    *Adrianna Chang*
+
+*   Revert breaking changes to `has_one` relationship deleting the old record before the new one is validated.
+
+    *zzak*
+
+*   Fix support for Active Record instances being uses in queries.
+
+    As of `7.0.5`, query arguments were deep duped to avoid mutations impacting
+    the query cache, but this had the adverse effect to clearing the primary key when
+    the query argument contained an `ActiveRecord::Base` instance.
+
+    This broke the `noticed` gem.
+
+    *Jean Boussier*
+
+
+## Rails 7.0.6 (June 29, 2023) ##
+
+*   Fix autosave associations with validations added on `:base` of the associated objects.
+
+    *fatkodima*
+
+*   Fix result with anonymous PostgreSQL columns of different type from json.
+
+    *Oleksandr Avoiants*
+
+*   Preserve timestamp when setting an `ActiveSupport::TimeWithZone` value to `timestamptz` attribute.
+
+    *fatkodima*
+
+*   Fix assignment into an `has_one` relationship deleting the old record before the new one is validated.
+
+    *Jean Boussier*
+
+*   Fix where on association with has_one/has_many polymorphic relations.
+
+    Before:
+    ```ruby
+    Treasure.where(price_estimates: PriceEstimate.all)
+    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates")
+    ```
+
+    Later:
+    ```ruby
+    Treasure.where(price_estimates: PriceEstimate.all)
+    #=> SELECT (...) WHERE "treasures"."id" IN (SELECT "price_estimates"."estimate_of_id" FROM "price_estimates" WHERE "price_estimates"."estimate_of_type" = 'Treasure')
+    ```
+
+    *Lázaro Nixon*
+
+*   Fix decrementing counter caches on optimistically locked record deletion
+
+    *fatkodima*
+
+*   Ensure binary-destined values have binary encoding during type cast.
+
+    *Matthew Draper*
+
+*   Preserve existing column default functions when altering table in SQLite.
+
+    *fatkodima*
+
+*   Remove table alias added when using `where.missing` or `where.associated`.
+
+    *fatkodima*
+
+*   Fix `Enumerable#in_order_of` to only flatten first level to preserve nesting.
+
+    *Miha Rekar*
+
+
+## Rails 7.0.5.1 (June 26, 2023) ##
+
+*   No changes.
+
 ## Rails 7.0.5 (May 24, 2023) ##
 
 *   Type cast `#attribute_changed?` `:from` and `:to` options.
@@ -76,7 +290,7 @@
 
     *Shota Toguchi*, *Yusaku Ono*
 
-*   Use connection from `#with_raw_connection` in `#quote_string`.
+*   Fix erroneous nil default precision on virtual datetime columns.
 
     Prior to this change, virtual datetime columns did not have the same
     default precision as regular datetime columns, resulting in the following

data/README.rdoc

@@ -192,7 +192,7 @@ The latest version of Active Record can be installed with RubyGems:
 
   $ gem install activerecord
 
-Source code can be downloaded as part of the Rails project on GitHub:
+Source code can be downloaded as part of the \Rails project on GitHub:
 
 * https://github.com/rails/rails/tree/main/activerecord
 
@@ -210,7 +210,7 @@ API documentation is at:
 
 * https://api.rubyonrails.org
 
-Bug reports for the Ruby on Rails project can be filed here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 

data/lib/active_record/associations/collection_association.rb

@@ -79,7 +79,7 @@ module ActiveRecord
       def reset
         super
         @target = []
-        @replaced_or_added_targets = Set.new
+        @replaced_or_added_targets = Set.new.compare_by_identity
         @association_ids = nil
       end
 

data/lib/active_record/associations/collection_proxy.rb

@@ -1102,6 +1102,11 @@ module ActiveRecord
         super
       end
 
+      def pretty_print(pp) # :nodoc:
+        load_target if find_from_target?
+        super
+      end
+
       delegate_methods = [
         QueryMethods,
         SpawnMethods,

data/lib/active_record/associations/has_one_association.rb

@@ -87,10 +87,6 @@ module ActiveRecord
           replace(record, false)
         end
 
-        def replace_keys(record, force: false)
-          # Has one association doesn't have foreign keys to replace.
-        end
-
         def remove_target!(method)
           case method
           when :delete

data/lib/active_record/associations/singular_association.rb

@@ -54,13 +54,11 @@ module ActiveRecord
         end
 
         def _create_record(attributes, raise_error = false, &block)
-          reflection.klass.transaction do
-            record = build(attributes, &block)
-            saved = record.save
-            replace_keys(record, force: true)
-            raise RecordInvalid.new(record) if !saved && raise_error
-            record
-          end
+          record = build_record(attributes, &block)
+          saved = record.save
+          set_new_record(record)
+          raise RecordInvalid.new(record) if !saved && raise_error
+          record
         end
     end
   end

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -264,7 +264,7 @@ module ActiveRecord
       #
       # generates:
       #
-      #   CREATE TABLE order (
+      #   CREATE TABLE orders (
       #       product_id bigint NOT NULL,
       #       client_id bigint NOT NULL
       #   );

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -71,14 +71,6 @@ module ActiveRecord
         /\A(?:[(\s]|#{COMMENT_REGEX})*#{Regexp.union(*parts)}/
       end
 
-      def self.quoted_column_names # :nodoc:
-        @quoted_column_names ||= {}
-      end
-
-      def self.quoted_table_names # :nodoc:
-        @quoted_table_names ||= {}
-      end
-
       def initialize(connection, logger = nil, config = {}) # :nodoc:
         super()
 
@@ -665,15 +657,6 @@ module ActiveRecord
         migration_context.current_version
       end
 
-      def field_ordered_value(column, values) # :nodoc:
-        node = Arel::Nodes::Case.new(column)
-        values.each.with_index(1) do |value, order|
-          node.when(value).then(order)
-        end
-
-        Arel::Nodes::Ascending.new(node.else(values.length + 1))
-      end
-
       class << self
         private
           def initialize_type_map(m)

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -138,11 +138,6 @@ module ActiveRecord
         true
       end
 
-      def field_ordered_value(column, values) # :nodoc:
-        field = Arel::Nodes::NamedFunction.new("FIELD", [column, values.reverse.map { |value| Arel::Nodes.build_quoted(value) }])
-        Arel::Nodes::Descending.new(field)
-      end
-
       def get_advisory_lock(lock_name, timeout = 0) # :nodoc:
         query_value("SELECT GET_LOCK(#{quote(lock_name.to_s)}, #{timeout})") == 1
       end
@@ -438,7 +433,8 @@ module ActiveRecord
               name: row["name"]
             }
             expression = row["expression"]
-            expression = expression[1..-2] unless mariadb? # remove parentheses added by mysql
+            expression = expression[1..-2] if expression.start_with?("(") && expression.end_with?(")")
+            expression = strip_whitespace_characters(expression)
             CheckConstraintDefinition.new(table_name, expression, options)
           end
         else
@@ -619,6 +615,12 @@ module ActiveRecord
       end
 
       private
+        def strip_whitespace_characters(expression)
+          expression = expression.gsub(/\\n|\\\\/, "")
+          expression = expression.gsub(/\s{2,}/, " ")
+          expression
+        end
+
         def text_type?(type)
           TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
         end

data/lib/active_record/connection_adapters/mysql/database_statements.rb

@@ -20,7 +20,7 @@ module ActiveRecord
         end
 
         READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
-          :desc, :describe, :set, :show, :use
+          :desc, :describe, :set, :show, :use, :kill
         ) # :nodoc:
         private_constant :READ_QUERY
 

data/lib/active_record/connection_adapters/mysql/quoting.rb

@@ -6,6 +6,9 @@ module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module Quoting # :nodoc:
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
         def quote_bound_value(value)
           case value
           when Rational
@@ -24,11 +27,11 @@ module ActiveRecord
         end
 
         def quote_column_name(name)
-          self.class.quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
+          QUOTED_COLUMN_NAMES[name] ||= "`#{super.gsub('`', '``')}`"
         end
 
         def quote_table_name(name)
-          self.class.quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
+          QUOTED_TABLE_NAMES[name] ||= super.gsub(".", "`.`").freeze
         end
 
         def unquoted_true

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -57,7 +57,7 @@ module ActiveRecord
             fields.each_with_index do |fname, i|
               ftype = result.ftype i
               fmod  = result.fmod i
-              types[fname] = get_oid_type(ftype, fmod, fname)
+              types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
             end
             build_result(columns: fields, rows: result.values, column_types: types)
           end

data/lib/active_record/connection_adapters/postgresql/oid/timestamp_with_time_zone.rb

@@ -13,7 +13,7 @@ module ActiveRecord
             return if value.blank?
 
             time = super
-            return time unless time.acts_like?(:time)
+            return time if time.is_a?(ActiveSupport::TimeWithZone) || !time.acts_like?(:time)
 
             # While in UTC mode, the PG gem may not return times back in "UTC" even if they were provided to Postgres in UTC.
             # We prefer times always in UTC, so here we convert back.

data/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -4,6 +4,9 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module Quoting
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
         class IntegerOutOf64BitRange < StandardError
           def initialize(msg)
             super(msg)
@@ -81,7 +84,7 @@ module ActiveRecord
         # - "schema.name".table_name
         # - "schema.name"."table.name"
         def quote_table_name(name) # :nodoc:
-          self.class.quoted_table_names[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
+          QUOTED_TABLE_NAMES[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
         end
 
         # Quotes schema names for use in SQL queries.
@@ -95,7 +98,7 @@ module ActiveRecord
 
         # Quotes column names for use in SQL queries.
         def quote_column_name(name) # :nodoc:
-          self.class.quoted_column_names[name] ||= PG::Connection.quote_ident(super).freeze
+          QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(super).freeze
         end
 
         # Quote date/time values for use in SQL input.

data/lib/active_record/connection_adapters/sqlite3/quoting.rb

@@ -4,6 +4,9 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLite3
       module Quoting # :nodoc:
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
         def quote_string(s)
           @connection.class.quote(s)
         end
@@ -13,11 +16,11 @@ module ActiveRecord
         end
 
         def quote_table_name(name)
-          self.class.quoted_table_names[name] ||= super.gsub(".", "\".\"").freeze
+          QUOTED_TABLE_NAMES[name] ||= super.gsub(".", "\".\"").freeze
         end
 
         def quote_column_name(name)
-          self.class.quoted_column_names[name] ||= %Q("#{super.gsub('"', '""')}")
+          QUOTED_COLUMN_NAMES[name] ||= %Q("#{super.gsub('"', '""')}")
         end
 
         def quoted_time(value)

data/lib/active_record/connection_adapters/sqlite3/schema_definitions.rb

@@ -4,6 +4,12 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLite3
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        def change_column(column_name, type, **options)
+          name = column_name.to_s
+          @columns_hash[name] = nil
+          column(name, type, **options)
+        end
+
         def references(*args, **options)
           super(*args, type: :integer, **options)
         end

data/lib/active_record/connection_adapters/sqlite3/schema_statements.rb

@@ -84,11 +84,11 @@ module ActiveRecord
           table_sql = query_value(<<-SQL, "SCHEMA")
             SELECT sql
             FROM sqlite_master
-            WHERE name = #{quote_table_name(table_name)} AND type = 'table'
+            WHERE name = #{quote(table_name)} AND type = 'table'
             UNION ALL
             SELECT sql
             FROM sqlite_temp_master
-            WHERE name = #{quote_table_name(table_name)} AND type = 'table'
+            WHERE name = #{quote(table_name)} AND type = 'table'
           SQL
 
           table_sql.to_s.scan(/CONSTRAINT\s+(?<name>\w+)\s+CHECK\s+\((?<expression>(:?[^()]|\(\g<expression>\))+)\)/i).map do |name, expression|

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -287,10 +287,7 @@ module ActiveRecord
 
       def change_column(table_name, column_name, type, **options) # :nodoc:
         alter_table(table_name) do |definition|
-          definition[column_name].instance_eval do
-            self.type = aliased_types(type.to_s, type)
-            self.options.merge!(options)
-          end
+          definition.change_column(column_name, type, **options)
         end
       end
 
@@ -480,6 +477,7 @@ module ActiveRecord
               if column.has_default?
                 type = lookup_cast_type_from_column(column)
                 default = type.deserialize(column.default)
+                default = -> { column.default_function } if default.nil?
               end
 
               @definition.column(column_name, column.type,

data/lib/active_record/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 7
     MINOR = 0
-    TINY  = 5
-    PRE   = nil
+    TINY  = 8
+    PRE   = "6"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/locking/optimistic.rb

@@ -2,14 +2,14 @@
 
 module ActiveRecord
   module Locking
-    # == What is Optimistic Locking
+    # == What is \Optimistic \Locking
     #
     # Optimistic locking allows multiple users to access the same record for edits, and assumes a minimum of
     # conflicts with the data. It does this by checking whether another process has made changes to a record since
-    # it was opened, an <tt>ActiveRecord::StaleObjectError</tt> exception is thrown if that has occurred
+    # it was opened, an ActiveRecord::StaleObjectError exception is thrown if that has occurred
     # and the update is ignored.
     #
-    # Check out <tt>ActiveRecord::Locking::Pessimistic</tt> for an alternative.
+    # Check out +ActiveRecord::Locking::Pessimistic+ for an alternative.
     #
     # == Usage
     #
@@ -69,6 +69,11 @@ module ActiveRecord
         end
       end
 
+      def initialize_dup(other) # :nodoc:
+        super
+        _clear_locking_column if locking_enabled?
+      end
+
       private
         def _create_record(attribute_names = self.attribute_names)
           if locking_enabled?
@@ -91,8 +96,7 @@ module ActiveRecord
             locking_column = self.class.locking_column
             lock_attribute_was = @attributes[locking_column]
 
-            update_constraints = _primary_key_constraints_hash
-            update_constraints[locking_column] = _lock_value_for_database(locking_column)
+            update_constraints = _query_constraints_hash
 
             attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
@@ -118,16 +122,9 @@ module ActiveRecord
         end
 
         def destroy_row
-          return super unless locking_enabled?
-
-          locking_column = self.class.locking_column
+          affected_rows = super
 
-          delete_constraints = _primary_key_constraints_hash
-          delete_constraints[locking_column] = _lock_value_for_database(locking_column)
-
-          affected_rows = self.class._delete_record(delete_constraints)
-
-          if affected_rows != 1
+          if locking_enabled? && affected_rows != 1
             raise ActiveRecord::StaleObjectError.new(self, "destroy")
           end
 
@@ -142,6 +139,18 @@ module ActiveRecord
           end
         end
 
+        def _clear_locking_column
+          self[self.class.locking_column] = nil
+          clear_attribute_change(self.class.locking_column)
+        end
+
+        def _query_constraints_hash
+          return super unless locking_enabled?
+
+          locking_column = self.class.locking_column
+          super.merge(locking_column => _lock_value_for_database(locking_column))
+        end
+
         module ClassMethods
           DEFAULT_LOCKING_COLUMN = "lock_version"
 
@@ -159,10 +168,7 @@ module ActiveRecord
           end
 
           # The version column used for optimistic locking. Defaults to +lock_version+.
-          def locking_column
-            @locking_column = DEFAULT_LOCKING_COLUMN unless defined?(@locking_column)
-            @locking_column
-          end
+          attr_reader :locking_column
 
           # Reset the column used for optimistic locking back to the +lock_version+ default.
           def reset_locking_column
@@ -182,6 +188,14 @@ module ActiveRecord
             end
             super
           end
+
+          private
+            def inherited(base)
+              super
+              base.class_eval do
+                @locking_column = DEFAULT_LOCKING_COLUMN
+              end
+            end
         end
     end
 

data/lib/active_record/migration/compatibility.rb

@@ -56,12 +56,13 @@ module ActiveRecord
           super
         end
 
-        def create_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
+        def change_column(table_name, column_name, type, **options)
+          if type == :datetime
+            options[:precision] ||= nil
           end
+
+          type = PostgreSQLCompat.compatible_timestamp_type(type, connection)
+          super
         end
 
         module TableDefinition
@@ -70,6 +71,11 @@ module ActiveRecord
             super
           end
 
+          def change(name, type, index: nil, **options)
+            options[:precision] ||= nil
+            super
+          end
+
           def column(name, type, index: nil, **options)
             options[:precision] ||= nil
             super
@@ -81,7 +87,7 @@ module ActiveRecord
             class << t
               prepend TableDefinition
             end
-            t
+            super
           end
       end
 
@@ -105,30 +111,6 @@ module ActiveRecord
           end
         end
 
-        def create_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
-        def change_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
-        def create_join_table(table_1, table_2, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
         def add_reference(table_name, ref_name, **options)
           if connection.adapter_name == "SQLite"
             options[:type] = :integer
@@ -182,30 +164,6 @@ module ActiveRecord
           end
         end
 
-        def create_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
-        def change_table(table_name, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
-        def create_join_table(table_1, table_2, **options)
-          if block_given?
-            super { |t| yield compatible_table_definition(t) }
-          else
-            super
-          end
-        end
-
         def add_timestamps(table_name, **options)
           options[:precision] ||= nil
           super

data/lib/active_record/migration.rb

@@ -551,6 +551,41 @@ module ActiveRecord
 
     # This must be defined before the inherited hook, below
     class Current < Migration # :nodoc:
+      def create_table(table_name, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def change_table(table_name, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def create_join_table(table_1, table_2, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def drop_table(table_name, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def compatible_table_definition(t)
+        t
+      end
     end
 
     def self.inherited(subclass) # :nodoc:
@@ -916,9 +951,7 @@ module ActiveRecord
     end
 
     def method_missing(method, *arguments, &block)
-      arg_list = arguments.map(&:inspect) * ", "
-
-      say_with_time "#{method}(#{arg_list})" do
+      say_with_time "#{method}(#{format_arguments(arguments)})" do
         unless connection.respond_to? :revert
           unless arguments.empty? || [:execute, :enable_extension, :disable_extension].include?(method)
             arguments[0] = proper_table_name(arguments.first, table_name_options)
@@ -1026,6 +1059,22 @@ module ActiveRecord
         end
       end
 
+      def format_arguments(arguments)
+        arg_list = arguments[0...-1].map(&:inspect)
+        last_arg = arguments.last
+        if last_arg.is_a?(Hash)
+          last_arg = last_arg.reject { |k, _v| internal_option?(k) }
+          arg_list << last_arg.inspect unless last_arg.empty?
+        else
+          arg_list << last_arg.inspect
+        end
+        arg_list.join(", ")
+      end
+
+      def internal_option?(option_name)
+        option_name.start_with?("_")
+      end
+
       def command_recorder
         CommandRecorder.new(connection)
       end

data/lib/active_record/persistence.rb

@@ -564,7 +564,7 @@ module ActiveRecord
     end
 
     # Returns true if this object was just created -- that is, prior to the last
-    # save, the object didn't exist in the database and new_record? would have
+    # update or delete, the object didn't exist in the database and new_record? would have
     # returned true.
     def previously_new_record?
       @previously_new_record
@@ -663,6 +663,7 @@ module ActiveRecord
     def delete
       _delete_row if persisted?
       @destroyed = true
+      @previously_new_record = false
       freeze
     end
 
@@ -682,6 +683,7 @@ module ActiveRecord
         true
       end
       @destroyed = true
+      @previously_new_record = false
       freeze
     end
 
@@ -813,7 +815,7 @@ module ActiveRecord
         verify_readonly_attribute(name) || name
       end
 
-      update_constraints = _primary_key_constraints_hash
+      update_constraints = _query_constraints_hash
       attributes = attributes.each_with_object({}) do |(k, v), h|
         h[k] = @attributes.write_cast_value(k, v)
         clear_attribute_change(k)
@@ -1028,7 +1030,7 @@ module ActiveRecord
         (self.class.default_scopes?(all_queries: true) || self.class.global_current_scope)
     end
 
-    def _primary_key_constraints_hash
+    def _query_constraints_hash
       { @primary_key => id_in_database }
     end
 
@@ -1041,7 +1043,7 @@ module ActiveRecord
     end
 
     def _delete_row
-      self.class._delete_record(_primary_key_constraints_hash)
+      self.class._delete_record(_query_constraints_hash)
     end
 
     def _touch_row(attribute_names, time)
@@ -1057,7 +1059,7 @@ module ActiveRecord
     def _update_row(attribute_names, attempted_action = "update")
       self.class._update_record(
         attributes_with_values(attribute_names),
-        _primary_key_constraints_hash
+        _query_constraints_hash
       )
     end
 

data/lib/active_record/railties/controller_runtime.rb

@@ -28,7 +28,7 @@ module ActiveRecord
         end
 
         def cleanup_view_runtime
-          if logger && logger.info? && ActiveRecord::Base.connected?
+          if logger && logger.info?
             db_rt_before_render = ActiveRecord::LogSubscriber.reset_runtime
             self.db_runtime = (db_runtime || 0) + db_rt_before_render
             runtime = super
@@ -42,9 +42,8 @@ module ActiveRecord
 
         def append_info_to_payload(payload)
           super
-          if ActiveRecord::Base.connected?
-            payload[:db_runtime] = (db_runtime || 0) + ActiveRecord::LogSubscriber.reset_runtime
-          end
+
+          payload[:db_runtime] = (db_runtime || 0) + ActiveRecord::LogSubscriber.reset_runtime
         end
     end
   end

data/lib/active_record/reflection.rb

@@ -485,6 +485,10 @@ module ActiveRecord
         foreign_key
       end
 
+      def join_primary_type
+        type
+      end
+
       def join_foreign_key
         active_record_primary_key
       end
@@ -588,6 +592,10 @@ module ActiveRecord
         options[:polymorphic]
       end
 
+      def polymorphic_name
+        active_record.polymorphic_name
+      end
+
       def add_as_source(seed)
         seed
       end

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

@@ -18,7 +18,10 @@ module ActiveRecord
         def ids
           case value
           when Relation
-            value.select_values.empty? ? value.select(primary_key) : value
+            relation = value
+            relation = relation.select(primary_key) if select_clause?
+            relation = relation.where(primary_type => polymorphic_name) if polymorphic_clause?
+            relation
           when Array
             value.map { |v| convert_to_id(v) }
           else
@@ -30,6 +33,22 @@ module ActiveRecord
           associated_table.join_primary_key
         end
 
+        def primary_type
+          associated_table.join_primary_type
+        end
+
+        def polymorphic_name
+          associated_table.polymorphic_name_association
+        end
+
+        def select_clause?
+          value.select_values.empty?
+        end
+
+        def polymorphic_clause?
+          primary_type && !value.where_values_hash.has_key?(primary_type)
+        end
+
         def convert_to_id(value)
           if value.respond_to?(primary_key)
             value.public_send(primary_key)

data/lib/active_record/relation/predicate_builder.rb

@@ -65,8 +65,7 @@ module ActiveRecord
     end
 
     def build_bind_attribute(column_name, value)
-      type = table.type(column_name)
-      Relation::QueryAttribute.new(column_name, type.immutable_value(value), type)
+      Relation::QueryAttribute.new(column_name, value, table.type(column_name))
     end
 
     def resolve_arel_attribute(table_name, column_name, &block)

data/lib/active_record/relation/query_attribute.rb

@@ -5,6 +5,20 @@ require "active_model/attribute"
 module ActiveRecord
   class Relation
     class QueryAttribute < ActiveModel::Attribute # :nodoc:
+      def initialize(...)
+        super
+
+        # The query attribute value may be mutated before we actually "compile" the query.
+        # To avoid that if the type uses a serializer we eagerly compute the value for database
+        if value_before_type_cast.is_a?(StatementCache::Substitute)
+          # we don't need to serialize StatementCache::Substitute
+        elsif @type.serialized?
+          value_for_database
+        elsif @type.mutable? # If the type is simply mutable, we deep_dup it.
+          @value_before_type_cast = @value_before_type_cast.deep_dup
+        end
+      end
+
       def type_cast(value)
         value
       end
@@ -35,6 +49,15 @@ module ActiveRecord
         @_unboundable
       end
 
+      def ==(other)
+        super && value_for_database == other.value_for_database
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, name, value_for_database, type].hash
+      end
+
       private
         def infinity?(value)
           value.respond_to?(:infinite?) && value.infinite?

data/lib/active_record/relation/query_methods.rb

@@ -77,7 +77,11 @@ module ActiveRecord
         associations.each do |association|
           reflection = scope_association_reflection(association)
           @scope.joins!(association)
-          self.not(association => { reflection.association_primary_key => nil })
+          if reflection.options[:class_name]
+            self.not(association => { reflection.association_primary_key => nil })
+          else
+            self.not(reflection.table_name => { reflection.association_primary_key => nil })
+          end
         end
 
         @scope
@@ -105,7 +109,11 @@ module ActiveRecord
         associations.each do |association|
           reflection = scope_association_reflection(association)
           @scope.left_outer_joins!(association)
-          @scope.where!(association => { reflection.association_primary_key => nil })
+          if reflection.options[:class_name]
+            @scope.where!(association => { reflection.association_primary_key => nil })
+          else
+            @scope.where!(reflection.table_name => { reflection.association_primary_key => nil })
+          end
         end
 
         @scope
@@ -436,13 +444,16 @@ module ActiveRecord
       self
     end
 
-    # Allows to specify an order by a specific set of values. Depending on your
-    # adapter this will either use a CASE statement or a built-in function.
+    # Allows to specify an order by a specific set of values.
     #
     #   User.in_order_of(:id, [1, 5, 3])
     #   # SELECT "users".* FROM "users"
-    #   #   ORDER BY FIELD("users"."id", 1, 5, 3)
     #   #   WHERE "users"."id" IN (1, 5, 3)
+    #   #   ORDER BY CASE
+    #   #     WHEN "users"."id" = 1 THEN 1
+    #   #     WHEN "users"."id" = 5 THEN 2
+    #   #     WHEN "users"."id" = 3 THEN 3
+    #   #   END ASC
     #
     def in_order_of(column, values)
       klass.disallow_raw_sql!([column], permit: connection.column_name_with_order_matcher)
@@ -454,9 +465,16 @@ module ActiveRecord
       values = values.map { |value| type_caster.type_cast_for_database(column, value) }
       arel_column = column.is_a?(Symbol) ? order_column(column.to_s) : column
 
+      where_clause =
+        if values.include?(nil)
+          arel_column.in(values.compact).or(arel_column.eq(nil))
+        else
+          arel_column.in(values)
+        end
+
       spawn
-        .order!(connection.field_ordered_value(arel_column, values))
-        .where!(arel_column.in(values))
+        .order!(build_case_for_value_position(arel_column, values))
+        .where!(where_clause)
     end
 
     # Replaces any existing order defined on the relation with the specified order.
@@ -1661,6 +1679,15 @@ module ActiveRecord
         end
       end
 
+      def build_case_for_value_position(column, values)
+        node = Arel::Nodes::Case.new
+        values.each.with_index(1) do |value, order|
+          node.when(column.eq(value)).then(order)
+        end
+
+        Arel::Nodes::Ascending.new(node)
+      end
+
       def resolve_arel_attributes(attrs)
         attrs.flat_map do |attr|
           case attr

data/lib/active_record/result.rb

@@ -108,7 +108,7 @@ module ActiveRecord
         type = if type_overrides.is_a?(Array)
           type_overrides.first
         else
-          column_type(columns.first, type_overrides)
+          column_type(columns.first, 0, type_overrides)
         end
 
         rows.map do |(value)|
@@ -118,7 +118,7 @@ module ActiveRecord
         types = if type_overrides.is_a?(Array)
           type_overrides
         else
-          columns.map { |name| column_type(name, type_overrides) }
+          columns.map.with_index { |name, i| column_type(name, i, type_overrides) }
         end
 
         rows.map do |values|
@@ -135,9 +135,11 @@ module ActiveRecord
     end
 
     private
-      def column_type(name, type_overrides = {})
+      def column_type(name, index, type_overrides)
         type_overrides.fetch(name) do
-          column_types.fetch(name, Type.default_value)
+          column_types.fetch(index) do
+            column_types.fetch(name, Type.default_value)
+          end
         end
       end
 

data/lib/active_record/table_metadata.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   class TableMetadata # :nodoc:
-    delegate :join_primary_key, :join_foreign_key, :join_foreign_type, to: :reflection
+    delegate :join_primary_key, :join_primary_type, :join_foreign_key, :join_foreign_type, to: :reflection
 
     def initialize(klass, arel_table, reflection = nil)
       @klass = klass
@@ -19,7 +19,7 @@ module ActiveRecord
     end
 
     def has_column?(column_name)
-      klass&.columns_hash.key?(column_name)
+      klass&.columns_hash&.key?(column_name)
     end
 
     def associated_with?(table_name)
@@ -54,6 +54,10 @@ module ActiveRecord
       reflection&.polymorphic?
     end
 
+    def polymorphic_name_association
+      reflection&.polymorphic_name
+    end
+
     def through_association?
       reflection&.through_reflection?
     end

data/lib/active_record/transactions.rb

@@ -336,9 +336,9 @@ module ActiveRecord
       @_trigger_update_callback = @_trigger_destroy_callback = false if force_restore_state
     end
 
-    # Executes +method+ within a transaction and captures its return value as a
-    # status flag. If the status is true the transaction is committed, otherwise
-    # a ROLLBACK is issued. In any case the status flag is returned.
+    # Executes a block within a transaction and captures its return value as a
+    # status flag. If the status is true, the transaction is committed,
+    # otherwise a ROLLBACK is issued. In any case, the status flag is returned.
     #
     # This method is available within the context of an ActiveRecord::Base
     # instance.

data/lib/active_record/type/serialized.rb

@@ -55,6 +55,10 @@ module ActiveRecord
         coder.respond_to?(:object_class) && value.is_a?(coder.object_class)
       end
 
+      def serialized? # :nodoc:
+        true
+      end
+
       private
         def default_value?(value)
           value == coder.load(nil)

data/lib/arel/nodes/and.rb

@@ -18,6 +18,10 @@ module Arel # :nodoc: all
         children[1]
       end
 
+      def fetch_attribute(&block)
+        children.any? && children.all? { |child| child.fetch_attribute(&block) }
+      end
+
       def hash
         children.hash
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 7.0.5
+  version: 7.0.8.6
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-24 00:00:00.000000000 Z
+date: 2024-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.5
+        version: 7.0.8.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.5
+        version: 7.0.8.6
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.5
+        version: 7.0.8.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.5
+        version: 7.0.8.6
 description: Databases on Rails. Build a persistent domain model by mapping database
   tables to Ruby classes. Strong conventions for associations, validations, aggregations,
   migrations, and testing come baked-in.
@@ -434,10 +434,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v7.0.5/activerecord/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v7.0.5/
+  changelog_uri: https://github.com/rails/rails/blob/v7.0.8.6/activerecord/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v7.0.8.6/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v7.0.5/activerecord
+  source_code_uri: https://github.com/rails/rails/tree/v7.0.8.6/activerecord
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options:
@@ -456,7 +456,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.16
 signing_key: 
 specification_version: 4
 summary: Object-relational mapper framework (part of Rails).