activerecord 8.0.0.1 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08d99704536322248d3c491dc890d68ae27698b4bb368e46a5e9ef40689bf988'
-  data.tar.gz: 910326d6346f200b00a670487236ad1e67862ba0746c869ea12ea283994ec74a
+  metadata.gz: 02db25501500ec8083c47291264f535dc9841c45d56a94e9aff93e826addf5f9
+  data.tar.gz: 504ac046514f4f733317b633f311e47ec0ba358d8d94fb92c9341988a49bd203
 SHA512:
-  metadata.gz: 32398ee71740d80113c849cf81bf8f8a60531df263042eeb87c38197d28b5f25b5c3805cc70aef9c4228c6b1d3571312ed0b7a1bee7713f02e0c40dec37d39e1
-  data.tar.gz: 0e6664b8b897e0997bfedc56d5cc3cc2524fb7df4fd4d2f3ee394079cdc08e1648155a75f215d38177e51eddc98a6ca817390a6149ee19eb64a65024f9b30602
+  metadata.gz: e13e206ccfcf6c7735ba154e0de054d211a49532206dadd5e0a678afd3c84f14a05da270afec364785f0dac69c117985164a61ca2021a82c0b8b724ea52b6ea0
+  data.tar.gz: 38d0436cb8ed82caf1ecad812d36be93c65a48919695a249e2182fa65504f585744362a35aeb93e9e6f83e285e9b34fed398c75e5ff9c97d9a974a952740ab20

data/CHANGELOG.md

@@ -1,3 +1,73 @@
+## Rails 8.0.1 (December 13, 2024) ##
+
+*   Fix removing foreign keys with :restrict action for MySQ
+
+    *fatkodima*
+
+*   Fix a race condition in `ActiveRecord::Base#method_missing` when lazily defining attributes.
+
+    If multiple thread were concurrently triggering attribute definition on the same model,
+    it could result in a `NoMethodError` being raised.
+
+    *Jean Boussier*
+
+*   Fix MySQL default functions getting dropped when changing a column's nullability.
+
+    *Bastian Bartmann*
+
+*   Fix `add_unique_constraint`/`add_check_constraint`/`add_foreign_key` to be revertible when given invalid options.
+
+    *fatkodima*
+
+*   Fix asynchronous destroying of polymorphic `belongs_to` associations.
+
+    *fatkodima*
+
+*   Fix `insert_all` to not update existing records.
+
+    *fatkodima*
+
+*   `NOT VALID` constraints should not dump in `create_table`.
+
+    *Ryuta Kamizono*
+
+*   Fix finding by nil composite primary key association.
+
+    *fatkodima*
+
+*   Properly reset composite primary key configuration when setting a primary key.
+
+    *fatkodima*
+
+*   Fix Mysql2Adapter support for prepared statements
+
+    Using prepared statements with MySQL could result in a `NoMethodError` exception.
+
+    *Jean Boussier*, *Leo Arnold*, *zzak*
+
+*   Fix parsing of SQLite foreign key names when they contain non-ASCII characters
+
+    *Zacharias Knudsen*
+
+*   Fix parsing of MySQL 8.0.16+ CHECK constraints when they contain new lines.
+
+    *Steve Hill*
+
+*   Ensure normalized attribute queries use `IS NULL` consistently for `nil` and normalized `nil` values.
+
+    *Joshua Young*
+
+*   Fix `sum` when performing a grouped calculation.
+
+    `User.group(:friendly).sum` no longer worked. This is fixed.
+
+    *Edouard Chin*
+
+*   Restore back the ability to pass only database name to `DATABASE_URL`.
+
+    *fatkodima*
+
+
 ## Rails 8.0.0.1 (December 10, 2024) ##
 
 *   No changes.
@@ -11,6 +81,7 @@
 
     *zzak*
 
+
 ## Rails 8.0.0.rc2 (October 30, 2024) ##
 
 *   NULLS NOT DISTINCT works with UNIQUE CONSTRAINT as well as UNIQUE INDEX.

data/lib/active_record/associations/belongs_to_association.rb

@@ -19,10 +19,16 @@ module ActiveRecord
             id = owner.public_send(reflection.foreign_key)
           end
 
+          association_class = if reflection.polymorphic?
+            owner.public_send(reflection.foreign_type)
+          else
+            reflection.klass
+          end
+
           enqueue_destroy_association(
             owner_model_name: owner.class.to_s,
             owner_id: owner.id,
-            association_class: reflection.klass.to_s,
+            association_class: association_class.to_s,
             association_ids: [id],
             association_primary_key_column: primary_key_column,
             ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)

data/lib/active_record/attribute_methods/primary_key.rb

@@ -129,12 +129,13 @@ module ActiveRecord
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
             @primary_key = if value.is_a?(Array)
-              @composite_primary_key = true
               include CompositePrimaryKey
               @primary_key = value.map { |v| -v.to_s }.freeze
             elsif value
               -value.to_s
             end
+
+            @composite_primary_key = value.is_a?(Array)
             @attributes_builder = nil
           end
 

data/lib/active_record/attribute_methods.rb

@@ -116,10 +116,11 @@ module ActiveRecord
             alias_attribute :id_value, :id if _has_attribute?("id")
           end
 
-          @attribute_methods_generated = true
-
           generate_alias_attributes
+
+          @attribute_methods_generated = true
         end
+
         true
       end
 
@@ -472,23 +473,27 @@ module ActiveRecord
       end
 
       def method_missing(name, ...)
-        unless self.class.attribute_methods_generated?
-          if self.class.method_defined?(name)
-            # The method is explicitly defined in the model, but calls a generated
-            # method with super. So we must resume the call chain at the right step.
-            last_method = method(name)
-            last_method = last_method.super_method while last_method.super_method
-            self.class.define_attribute_methods
-            if last_method.super_method
-              return last_method.super_method.call(...)
-            end
-          elsif self.class.define_attribute_methods
-            # Some attribute methods weren't generated yet, we retry the call
-            return public_send(name, ...)
-          end
+        # We can't know whether some method was defined or not because
+        # multiple thread might be concurrently be in this code path.
+        # So the first one would define the methods and the others would
+        # appear to already have them.
+        self.class.define_attribute_methods
+
+        # So in all cases we must behave as if the method was just defined.
+        method = begin
+          self.class.public_instance_method(name)
+        rescue NameError
+          nil
         end
 
-        super
+        # The method might be explicitly defined in the model, but call a generated
+        # method with super. So we must resume the call chain at the right step.
+        method = method.super_method while method && !method.owner.is_a?(GeneratedAttributeMethods)
+        if method
+          method.bind_call(self, ...)
+        else
+          super
+        end
       end
 
       def attribute_method?(attr_name)

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

@@ -117,24 +117,30 @@ module ActiveRecord
     # * private methods that require being called in a +synchronize+ blocks
     #   are now explicitly documented
     class ConnectionPool
-      class WeakThreadKeyMap # :nodoc:
-        # FIXME: On 3.3 we could use ObjectSpace::WeakKeyMap
-        # but it currently cause GC crashes: https://github.com/byroot/rails/pull/3
-        def initialize
-          @map = {}
-        end
-
-        def clear
-          @map.clear
-        end
+      # Prior to 3.3.5, WeakKeyMap had a use after free bug
+      # https://bugs.ruby-lang.org/issues/20688
+      if ObjectSpace.const_defined?(:WeakKeyMap) && RUBY_VERSION >= "3.3.5"
+        WeakThreadKeyMap = ObjectSpace::WeakKeyMap
+      else
+        class WeakThreadKeyMap # :nodoc:
+          # FIXME: On 3.3 we could use ObjectSpace::WeakKeyMap
+          # but it currently cause GC crashes: https://github.com/byroot/rails/pull/3
+          def initialize
+            @map = {}
+          end
+
+          def clear
+            @map.clear
+          end
 
-        def [](key)
-          @map[key]
-        end
+          def [](key)
+            @map[key]
+          end
 
-        def []=(key, value)
-          @map.select! { |c, _| c.alive? }
-          @map[key] = value
+          def []=(key, value)
+            @map.select! { |c, _| c&.alive? }
+            @map[key] = value
+          end
         end
       end
 
@@ -687,6 +693,14 @@ module ActiveRecord
         Thread.pass
       end
 
+      def new_connection # :nodoc:
+        connection = db_config.new_connection
+        connection.pool = self
+        connection
+      rescue ConnectionNotEstablished => ex
+        raise ex.set_pool(self)
+      end
+
       private
         def connection_lease
           @leases[ActiveSupport::IsolatedExecutionState.context]
@@ -866,18 +880,12 @@ module ActiveRecord
         #--
         # if owner_thread param is omitted, this must be called in synchronize block
         def remove_connection_from_thread_cache(conn, owner_thread = conn.owner)
-          @leases[owner_thread].clear(conn)
+          if owner_thread
+            @leases[owner_thread].clear(conn)
+          end
         end
         alias_method :release, :remove_connection_from_thread_cache
 
-        def new_connection
-          connection = db_config.new_connection
-          connection.pool = self
-          connection
-        rescue ConnectionNotEstablished => ex
-          raise ex.set_pool(self)
-        end
-
         # If the pool is not at a <tt>@size</tt> limit, establish new connection. Connecting
         # to the DB is done outside main synchronized section.
         #--

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

@@ -159,6 +159,8 @@ module ActiveRecord
       end
 
       def defined_for?(to_table: nil, validate: nil, **options)
+        options = options.slice(*self.options.keys)
+
         (to_table.nil? || to_table.to_s == self.to_table) &&
           (validate.nil? || validate == self.options.fetch(:validate, validate)) &&
           options.all? { |k, v| Array(self.options[k]).map(&:to_s) == Array(v).map(&:to_s) }
@@ -185,6 +187,8 @@ module ActiveRecord
       end
 
       def defined_for?(name:, expression: nil, validate: nil, **options)
+        options = options.slice(*self.options.keys)
+
         self.name == name.to_s &&
           (validate.nil? || validate == self.options.fetch(:validate, validate)) &&
           options.all? { |k, v| self.options[k].to_s == v.to_s }

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -403,7 +403,11 @@ module ActiveRecord
         type ||= column.sql_type
 
         unless options.key?(:default)
-          options[:default] = column.default
+          options[:default] = if column.default_function
+            -> { column.default_function }
+          else
+            column.default
+          end
         end
 
         unless options.key?(:null)
@@ -628,24 +632,26 @@ module ActiveRecord
       end
 
       def build_insert_sql(insert) # :nodoc:
+        # Can use any column as it will be assigned to itself.
         no_op_column = quote_column_name(insert.keys.first) if insert.keys.first
 
         # MySQL 8.0.19 replaces `VALUES(<expression>)` clauses with row and column alias names, see https://dev.mysql.com/worklog/task/?id=6312 .
         # then MySQL 8.0.20 deprecates the `VALUES(<expression>)` see https://dev.mysql.com/worklog/task/?id=13325 .
         if supports_insert_raw_alias_syntax?
+          quoted_table_name = insert.model.quoted_table_name
           values_alias = quote_table_name("#{insert.model.table_name.parameterize}_values")
           sql = +"INSERT #{insert.into} #{insert.values_list} AS #{values_alias}"
 
           if insert.skip_duplicates?
             if no_op_column
-              sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{values_alias}.#{no_op_column}"
+              sql << " ON DUPLICATE KEY UPDATE #{no_op_column}=#{quoted_table_name}.#{no_op_column}"
             end
           elsif insert.update_duplicates?
             if insert.raw_update_sql?
               sql = +"INSERT #{insert.into} #{insert.values_list} ON DUPLICATE KEY UPDATE #{insert.raw_update_sql}"
             else
               sql << " ON DUPLICATE KEY UPDATE "
-              sql << insert.touch_model_timestamps_unless { |column| "#{insert.model.quoted_table_name}.#{column}<=>#{values_alias}.#{column}" }
+              sql << insert.touch_model_timestamps_unless { |column| "#{quoted_table_name}.#{column}<=>#{values_alias}.#{column}" }
               sql << insert.updatable_columns.map { |column| "#{column}=#{values_alias}.#{column}" }.join(",")
             end
           end
@@ -746,9 +752,7 @@ module ActiveRecord
 
       private
         def strip_whitespace_characters(expression)
-          expression = expression.gsub(/\\n|\\\\/, "")
-          expression = expression.gsub(/\s{2,}/, " ")
-          expression
+          expression.gsub('\\\n', "").gsub("x0A", "").squish
         end
 
         def extended_type_map_key
@@ -762,7 +766,6 @@ module ActiveRecord
         def handle_warnings(sql)
           return if ActiveRecord.db_warnings_action.nil? || @raw_connection.warning_count == 0
 
-          @affected_rows_before_warnings = @raw_connection.affected_rows
           warning_count = @raw_connection.warning_count
           result = @raw_connection.query("SHOW WARNINGS")
           result = [

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

@@ -102,7 +102,13 @@ module ActiveRecord
             else
               value.getlocal
             end
-          when Date, Time
+          when Time
+            if default_timezone == :utc
+              value.utc? ? value : value.getutc
+            else
+              value.utc? ? value.getlocal : value
+            end
+          when Date
             value
           else
             super

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

@@ -85,6 +85,13 @@ module ActiveRecord
           super
         end
 
+        def remove_foreign_key(from_table, to_table = nil, **options)
+          # RESTRICT is by default in MySQL.
+          options.delete(:on_update) if options[:on_update] == :restrict
+          options.delete(:on_delete) if options[:on_delete] == :restrict
+          super
+        end
+
         def internal_string_options_for_primary_key
           super.tap do |options|
             if !row_format_dynamic_by_default? && CHARSETS_OF_4BYTES_MAXLEN.include?(charset)

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

@@ -48,26 +48,55 @@ module ActiveRecord
             # made since we established the connection
             raw_connection.query_options[:database_timezone] = default_timezone
 
-            result = if prepare
+            result = nil
+            if binds.nil? || binds.empty?
+              ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                result = raw_connection.query(sql)
+                # Ref: https://github.com/brianmario/mysql2/pull/1383
+                # As of mysql2 0.5.6 `#affected_rows` might raise Mysql2::Error if a prepared statement
+                # from that same connection was GCed while `#query` released the GVL.
+                # By avoiding to call `#affected_rows` when we have a result, we reduce the likeliness
+                # of hitting the bug.
+                @affected_rows_before_warnings = result&.size || raw_connection.affected_rows
+              end
+            elsif prepare
               stmt = @statements[sql] ||= raw_connection.prepare(sql)
-
               begin
                 ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                  stmt.execute(*type_casted_binds)
+                  result = stmt.execute(*type_casted_binds)
+                  @affected_rows_before_warnings = stmt.affected_rows
                 end
               rescue ::Mysql2::Error
                 @statements.delete(sql)
-                stmt.close
                 raise
               end
-              verified!
             else
-              raw_connection.query(sql)
+              stmt = raw_connection.prepare(sql)
+
+              begin
+                ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                  result = stmt.execute(*type_casted_binds)
+                  @affected_rows_before_warnings = stmt.affected_rows
+                end
+
+                # Ref: https://github.com/brianmario/mysql2/pull/1383
+                # by eagerly closing uncached prepared statements, we also reduce the chances of
+                # that bug happening. It can still happen if `#execute` is used as we have no callback
+                # to eagerly close the statement.
+                if result
+                  result.instance_variable_set(:@_ar_stmt_to_close, stmt)
+                else
+                  stmt.close
+                end
+              rescue ::Mysql2::Error
+                stmt.close
+                raise
+              end
             end
 
+            notification_payload[:affected_rows] = @affected_rows_before_warnings
             notification_payload[:row_count] = result&.size || 0
 
-            @affected_rows_before_warnings = raw_connection.affected_rows
             raw_connection.abandon_results!
 
             verified!
@@ -79,17 +108,34 @@ module ActiveRecord
             end
           end
 
-          def cast_result(result)
-            if result.nil? || result.fields.empty?
+          def cast_result(raw_result)
+            return ActiveRecord::Result.empty if raw_result.nil?
+
+            fields = raw_result.fields
+
+            result = if fields.empty?
               ActiveRecord::Result.empty
             else
-              ActiveRecord::Result.new(result.fields, result.to_a)
+              ActiveRecord::Result.new(fields, raw_result.to_a)
             end
+
+            free_raw_result(raw_result)
+
+            result
           end
 
-          def affected_rows(result)
+          def affected_rows(raw_result)
+            free_raw_result(raw_result) if raw_result
+
             @affected_rows_before_warnings
           end
+
+          def free_raw_result(raw_result)
+            raw_result.free
+            if stmt = raw_result.instance_variable_get(:@_ar_stmt_to_close)
+              stmt.close
+            end
+          end
       end
     end
   end

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

@@ -233,6 +233,8 @@ module ActiveRecord
         end
 
         def defined_for?(name: nil, column: nil, **options)
+          options = options.slice(*self.options.keys)
+
           (name.nil? || self.name == name.to_s) &&
             (column.nil? || Array(self.column) == Array(column).map(&:to_s)) &&
             options.all? { |k, v| self.options[k].to_s == v.to_s }

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

@@ -922,7 +922,7 @@ module ActiveRecord
         #
         #   validate_check_constraint :products, name: "price_check"
         #
-        # The +options+ hash accepts the same keys as add_check_constraint[rdoc-ref:ConnectionAdapters::SchemaStatements#add_check_constraint].
+        # The +options+ hash accepts the same keys as {add_check_constraint}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_check_constraint].
         def validate_check_constraint(table_name, **options)
           chk_name_to_validate = check_constraint_for!(table_name, **options).name
 

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

@@ -137,7 +137,11 @@ module ActiveRecord
           end
 
           def default_insert_value(column)
-            column.default
+            if column.default_function
+              Arel.sql(column.default_function)
+            else
+              column.default
+            end
           end
       end
     end

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

@@ -27,6 +27,7 @@ module ActiveRecord
               col["name"]
             end
 
+            where = where.sub(/\s*\/\*.*\*\/\z/, "") if where
             orders = {}
 
             if columns.any?(&:nil?) # index created with an expression
@@ -74,6 +75,7 @@ module ActiveRecord
               Base.pluralize_table_names ? table.pluralize : table
             end
             table = strip_table_name_prefix_and_suffix(table)
+            options = options.slice(*fk.options.keys)
             fk_to_table = strip_table_name_prefix_and_suffix(fk.to_table)
             fk_to_table == table && options.all? { |k, v| fk.options[k].to_s == v.to_s }
           end || raise(ArgumentError, "Table '#{from_table}' has no foreign key for #{to_table || options}")

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -407,7 +407,7 @@ module ActiveRecord
       end
       alias :add_belongs_to :add_reference
 
-      FK_REGEX = /.*FOREIGN KEY\s+\("(\w+)"\)\s+REFERENCES\s+"(\w+)"\s+\("(\w+)"\)/
+      FK_REGEX = /.*FOREIGN KEY\s+\("([^"]+)"\)\s+REFERENCES\s+"(\w+)"\s+\("(\w+)"\)/
       DEFERRABLE_REGEX = /DEFERRABLE INITIALLY (\w+)/
       def foreign_keys(table_name)
         # SQLite returns 1 row for each column of composite foreign keys.

data/lib/active_record/connection_adapters/statement_pool.rb

@@ -50,8 +50,10 @@ module ActiveRecord
       end
 
       def delete(key)
-        dealloc cache[key]
-        cache.delete(key)
+        if stmt = cache.delete(key)
+          dealloc(stmt)
+        end
+        stmt
       end
 
       private

data/lib/active_record/database_configurations/connection_url_resolver.rb

@@ -81,7 +81,9 @@ module ActiveRecord
 
         def resolved_adapter
           adapter = uri.scheme && @uri.scheme.tr("-", "_")
-          adapter = ActiveRecord.protocol_adapters[adapter] || adapter
+          if adapter && ActiveRecord.protocol_adapters[adapter]
+            adapter = ActiveRecord.protocol_adapters[adapter]
+          end
           adapter
         end
 

data/lib/active_record/gem_version.rb

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

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

@@ -59,6 +59,8 @@ module ActiveRecord
         def convert_to_id(value)
           if primary_key.is_a?(Array)
             primary_key.map do |attribute|
+              next nil if value.nil?
+
               if attribute == "id"
                 value.id_value
               else

data/lib/active_record/relation/query_attribute.rb

@@ -35,7 +35,7 @@ module ActiveRecord
       def nil?
         unless value_before_type_cast.is_a?(StatementCache::Substitute)
           value_before_type_cast.nil? ||
-            type.respond_to?(:subtype) && serializable? && value_for_database.nil?
+            (type.respond_to?(:subtype) || type.respond_to?(:normalizer)) && serializable? && value_for_database.nil?
         end
       end
 

data/lib/active_record/relation/query_methods.rb

@@ -1990,7 +1990,7 @@ module ActiveRecord
       def arel_column(field)
         field = field.name if is_symbol = field.is_a?(Symbol)
 
-        field = model.attribute_aliases[field] || field
+        field = model.attribute_aliases[field] || field.to_s
         from = from_clause.name || from_clause.value
 
         if model.columns_hash.key?(field) && (!from || table_name_matches?(from))

data/lib/active_record/schema_dumper.rb

@@ -207,12 +207,17 @@ module ActiveRecord
           end
 
           indexes_in_create(table, tbl)
-          check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
+          remaining = check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
           exclusion_constraints_in_create(table, tbl) if @connection.supports_exclusion_constraints?
           unique_constraints_in_create(table, tbl) if @connection.supports_unique_constraints?
 
           tbl.puts "  end"
 
+          if remaining
+            tbl.puts
+            tbl.print remaining.string
+          end
+
           stream.print tbl.string
         rescue => e
           stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
@@ -277,24 +282,37 @@ module ActiveRecord
 
       def check_constraints_in_create(table, stream)
         if (check_constraints = @connection.check_constraints(table)).any?
-          add_check_constraint_statements = check_constraints.map do |check_constraint|
-            parts = [
-              "t.check_constraint #{check_constraint.expression.inspect}"
-            ]
+          check_valid, check_invalid = check_constraints.partition { |chk| chk.validate? }
 
-            if check_constraint.export_name_on_schema_dump?
-              parts << "name: #{check_constraint.name.inspect}"
+          unless check_valid.empty?
+            check_constraint_statements = check_valid.map do |check|
+              "    t.check_constraint #{check_parts(check).join(', ')}"
             end
 
-            parts << "validate: #{check_constraint.validate?.inspect}" unless check_constraint.validate?
-
-            "    #{parts.join(', ')}"
+            stream.puts check_constraint_statements.sort.join("\n")
           end
 
-          stream.puts add_check_constraint_statements.sort.join("\n")
+          unless check_invalid.empty?
+            remaining = StringIO.new
+            table_name = remove_prefix_and_suffix(table).inspect
+
+            add_check_constraint_statements = check_invalid.map do |check|
+              "  add_check_constraint #{([table_name] + check_parts(check)).join(', ')}"
+            end
+
+            remaining.puts add_check_constraint_statements.sort.join("\n")
+            remaining
+          end
         end
       end
 
+      def check_parts(check)
+        check_parts = [ check.expression.inspect ]
+        check_parts << "name: #{check.name.inspect}" if check.export_name_on_schema_dump?
+        check_parts << "validate: #{check.validate?.inspect}" unless check.validate?
+        check_parts
+      end
+
       def foreign_keys(table, stream)
         if (foreign_keys = @connection.foreign_keys(table)).any?
           add_foreign_key_statements = foreign_keys.map do |foreign_key|

data/lib/active_record.rb

@@ -548,8 +548,10 @@ module ActiveRecord
     open_transactions = []
     Base.connection_handler.each_connection_pool do |pool|
       if active_connection = pool.active_connection
-        if active_connection.current_transaction.open? && active_connection.current_transaction.joinable?
-          open_transactions << active_connection.current_transaction
+        current_transaction = active_connection.current_transaction
+
+        if current_transaction.open? && current_transaction.joinable? && !current_transaction.state.invalidated?
+          open_transactions << current_transaction
         end
       end
     end

metadata

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