activerecord 8.1.0.beta1 → 8.1.0

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

@@ -3,24 +3,24 @@
 module ActiveRecord
   class PredicateBuilder
     class PolymorphicArrayValue # :nodoc:
-      def initialize(associated_table, values)
-        @associated_table = associated_table
+      def initialize(reflection, values)
+        @reflection = reflection
         @values = values
       end
 
       def queries
-        return [ associated_table.join_foreign_key => values ] if values.empty?
+        return [ reflection.join_foreign_key => values ] if values.empty?
 
         type_to_ids_mapping.map do |type, ids|
           query = {}
-          query[associated_table.join_foreign_type] = type if type
-          query[associated_table.join_foreign_key] = ids
+          query[reflection.join_foreign_type] = type if type
+          query[reflection.join_foreign_key] = ids
           query
         end
       end
 
       private
-        attr_reader :associated_table, :values
+        attr_reader :reflection, :values
 
         def type_to_ids_mapping
           default_hash = Hash.new { |hsh, key| hsh[key] = [] }
@@ -30,7 +30,7 @@ module ActiveRecord
         end
 
         def primary_key(value)
-          associated_table.join_primary_key(klass(value))
+          reflection.join_primary_key(klass(value))
         end
 
         def klass(value)

data/lib/active_record/relation/predicate_builder.rb

@@ -99,24 +99,26 @@ module ActiveRecord
           elsif value.is_a?(Hash) && !table.has_column?(key)
             table.associated_table(key, &block)
               .predicate_builder.expand_from_hash(value.stringify_keys)
-          elsif table.associated_with?(key)
+          elsif (associated_reflection = table.associated_with(key))
             # Find the foreign key when using queries such as:
             # Post.where(author: author)
             #
             # For polymorphic relationships, find the foreign key and type:
             # PriceEstimate.where(estimate_of: treasure)
-            associated_table = table.associated_table(key)
-            if associated_table.polymorphic_association?
+
+            if associated_reflection.polymorphic?
               value = [value] unless value.is_a?(Array)
               klass = PolymorphicArrayValue
-            elsif associated_table.through_association?
+            elsif associated_reflection.through_reflection?
+              associated_table = table.associated_table(key)
+
               next associated_table.predicate_builder.expand_from_hash(
                 associated_table.primary_key => value
               )
             end
 
             klass ||= AssociationQueryValue
-            queries = klass.new(associated_table, value).queries.map! do |query|
+            queries = klass.new(associated_reflection, value).queries.map! do |query|
               # If the query produced is identical to attributes don't go any deeper.
               # Prevents stack level too deep errors when association and foreign_key are identical.
               query == attributes ? self[key, value] : expand_from_hash(query)

data/lib/active_record/relation/query_methods.rb

@@ -426,7 +426,7 @@ module ActiveRecord
     end
 
     def _select!(*fields) # :nodoc:
-      self.select_values += fields
+      self.select_values |= fields
       self
     end
 
@@ -1923,7 +1923,8 @@ module ActiveRecord
 
       def build_with_expression_from_value(value, nested = false)
         case value
-        when Arel::Nodes::SqlLiteral then Arel::Nodes::Grouping.new(value)
+        when Arel::Nodes::SqlLiteral, Arel::Nodes::BoundSqlLiteral
+          Arel::Nodes::Grouping.new(value)
         when ActiveRecord::Relation
           if nested
             value.arel.ast

data/lib/active_record/relation/where_clause.rb

@@ -176,6 +176,8 @@ module ActiveRecord
         end
 
         def except_predicates(columns)
+          return predicates if columns.empty?
+
           attrs = columns.extract! { |node| node.is_a?(Arel::Attribute) }
           non_attrs = columns.extract! { |node| node.is_a?(Arel::Predications) }
 

data/lib/active_record/relation.rb

@@ -307,7 +307,7 @@ module ActiveRecord
       end
     end
 
-    # Like #find_or_create_by, but calls {new}[rdoc-ref:Core#new]
+    # Like #find_or_create_by, but calls {new}[rdoc-ref:Core.new]
     # instead of {create}[rdoc-ref:Persistence::ClassMethods#create].
     def find_or_initialize_by(attributes, &block)
       find_by(attributes) || new(attributes, &block)

data/lib/active_record/runtime_registry.rb

@@ -3,80 +3,63 @@
 module ActiveRecord
   # This is a thread locals registry for Active Record. For example:
   #
-  #   ActiveRecord::RuntimeRegistry.sql_runtime
+  #   ActiveRecord::RuntimeRegistry.stats.sql_runtime
   #
   # returns the connection handler local to the current unit of execution (either thread of fiber).
   module RuntimeRegistry # :nodoc:
-    extend self
-
-    def sql_runtime
-      ActiveSupport::IsolatedExecutionState[:active_record_sql_runtime] ||= 0.0
+    class Stats
+      attr_accessor :sql_runtime, :async_sql_runtime, :queries_count, :cached_queries_count
+
+      def initialize
+        @sql_runtime = 0.0
+        @async_sql_runtime = 0.0
+        @queries_count = 0
+        @cached_queries_count = 0
+      end
+
+      def reset_runtimes
+        sql_runtime_was = @sql_runtime
+        @sql_runtime = 0.0
+        @async_sql_runtime = 0.0
+        sql_runtime_was
+      end
+
+      public alias_method :reset, :initialize
     end
 
-    def sql_runtime=(runtime)
-      ActiveSupport::IsolatedExecutionState[:active_record_sql_runtime] = runtime
-    end
-
-    def async_sql_runtime
-      ActiveSupport::IsolatedExecutionState[:active_record_async_sql_runtime] ||= 0.0
-    end
+    extend self
 
-    def async_sql_runtime=(runtime)
-      ActiveSupport::IsolatedExecutionState[:active_record_async_sql_runtime] = runtime
+    def call(name, start, finish, id, payload)
+      record(
+        payload[:name],
+        (finish - start) * 1_000.0,
+        async: payload[:async],
+        lock_wait: payload[:lock_wait],
+      )
     end
 
-    def queries_count
-      ActiveSupport::IsolatedExecutionState[:active_record_queries_count] ||= 0
-    end
+    def record(query_name, runtime, cached: false, async: false, lock_wait: nil)
+      stats = self.stats
 
-    def queries_count=(count)
-      ActiveSupport::IsolatedExecutionState[:active_record_queries_count] = count
-    end
+      unless query_name == "TRANSACTION" || query_name == "SCHEMA"
+        stats.queries_count += 1
+        stats.cached_queries_count += 1 if cached
+      end
 
-    def cached_queries_count
-      ActiveSupport::IsolatedExecutionState[:active_record_cached_queries_count] ||= 0
+      if async
+        stats.async_sql_runtime += (runtime - lock_wait)
+      end
+      stats.sql_runtime += runtime
     end
 
-    def cached_queries_count=(count)
-      ActiveSupport::IsolatedExecutionState[:active_record_cached_queries_count] = count
+    def stats
+      ActiveSupport::IsolatedExecutionState[:active_record_runtime] ||= Stats.new
     end
 
     def reset
-      reset_runtimes
-      reset_queries_count
-      reset_cached_queries_count
-    end
-
-    def reset_runtimes
-      rt, self.sql_runtime = sql_runtime, 0.0
-      self.async_sql_runtime = 0.0
-      rt
-    end
-
-    def reset_queries_count
-      qc = queries_count
-      self.queries_count = 0
-      qc
-    end
-
-    def reset_cached_queries_count
-      qc = cached_queries_count
-      self.cached_queries_count = 0
-      qc
+      stats.reset
     end
   end
 end
 
-ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |name, start, finish, id, payload|
-  unless ["SCHEMA", "TRANSACTION"].include?(payload[:name])
-    ActiveRecord::RuntimeRegistry.queries_count += 1
-    ActiveRecord::RuntimeRegistry.cached_queries_count += 1 if payload[:cached]
-  end
-
-  runtime = (finish - start) * 1_000.0
-
-  if payload[:async]
-    ActiveRecord::RuntimeRegistry.async_sql_runtime += (runtime - payload[:lock_wait])
-  end
-  ActiveRecord::RuntimeRegistry.sql_runtime += runtime
-end
+ActiveSupport::Notifications.monotonic_subscribe("sql.active_record", ActiveRecord::RuntimeRegistry)

data/lib/active_record/structured_event_subscriber.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "active_support/structured_event_subscriber"
+
+module ActiveRecord
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
+
+    def strict_loading_violation(event)
+      owner = event.payload[:owner]
+      reflection = event.payload[:reflection]
+
+      emit_debug_event("active_record.strict_loading_violation",
+        owner: owner.name,
+        class: reflection.polymorphic? ? nil : reflection.klass.name,
+        name: reflection.name,
+      )
+    end
+    debug_only :strict_loading_violation
+
+    def sql(event)
+      payload = event.payload
+
+      return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
+
+      binds = nil
+
+      if payload[:binds]&.any?
+        casted_params = type_casted_binds(payload[:type_casted_binds])
+
+        binds = []
+        payload[:binds].each_with_index do |attr, i|
+          attribute_name = if attr.respond_to?(:name)
+            attr.name
+          elsif attr.respond_to?(:[]) && attr[i].respond_to?(:name)
+            attr[i].name
+          else
+            nil
+          end
+
+          filtered_params = filter(attribute_name, casted_params[i])
+
+          binds << render_bind(attr, filtered_params)
+        end
+      end
+
+      emit_debug_event("active_record.sql",
+        async: payload[:async],
+        name: payload[:name],
+        sql: payload[:sql],
+        cached: payload[:cached],
+        lock_wait: payload[:lock_wait],
+        binds: binds,
+        duration_ms: event.duration.round(2),
+      )
+    end
+    debug_only :sql
+
+    private
+      def type_casted_binds(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
+      end
+
+      def render_bind(attr, value)
+        case attr
+        when ActiveModel::Attribute
+          if attr.type.binary? && attr.value
+            value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+          end
+        when Array
+          attr = attr.first
+        else
+          attr = nil
+        end
+
+        [attr&.name, value]
+      end
+
+      def filter(name, value)
+        ActiveRecord::Base.inspection_filter.filter_param(name, value)
+      end
+  end
+end
+
+ActiveRecord::StructuredEventSubscriber.attach_to :active_record

data/lib/active_record/table_metadata.rb

@@ -2,12 +2,9 @@
 
 module ActiveRecord
   class TableMetadata # :nodoc:
-    delegate :join_primary_key, :join_primary_type, :join_foreign_key, :join_foreign_type, to: :reflection
-
-    def initialize(klass, arel_table, reflection = nil)
+    def initialize(klass, arel_table)
       @klass = klass
       @arel_table = arel_table
-      @reflection = reflection
     end
 
     def primary_key
@@ -22,7 +19,7 @@ module ActiveRecord
       klass&.columns_hash&.key?(column_name)
     end
 
-    def associated_with?(table_name)
+    def associated_with(table_name)
       klass&._reflect_on_association(table_name)
     end
 
@@ -42,26 +39,14 @@ module ActiveRecord
       if association_klass
         arel_table = association_klass.arel_table
         arel_table = arel_table.alias(table_name) if arel_table.name != table_name
-        TableMetadata.new(association_klass, arel_table, reflection)
+        TableMetadata.new(association_klass, arel_table)
       else
         type_caster = TypeCaster::Connection.new(klass, table_name)
         arel_table = Arel::Table.new(table_name, type_caster: type_caster)
-        TableMetadata.new(nil, arel_table, reflection)
+        TableMetadata.new(nil, arel_table)
       end
     end
 
-    def polymorphic_association?
-      reflection&.polymorphic?
-    end
-
-    def polymorphic_name_association
-      reflection&.polymorphic_name
-    end
-
-    def through_association?
-      reflection&.through_reflection?
-    end
-
     def reflect_on_aggregation(aggregation_name)
       klass&.reflect_on_aggregation(aggregation_name)
     end
@@ -78,6 +63,6 @@ module ActiveRecord
     attr_reader :arel_table
 
     private
-      attr_reader :klass, :reflection
+      attr_reader :klass
   end
 end

data/lib/active_record/tasks/database_tasks.rb

@@ -428,9 +428,15 @@ module ActiveRecord
       end
 
       def dump_all
-        with_temporary_pool_for_each do |pool|
-          db_config = pool.db_config
+        seen_schemas = []
+
+        ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
+          schema_path = schema_dump_path(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+
+          next if seen_schemas.include?(schema_path)
+
           ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+          seen_schemas << schema_path
         end
       end
 
@@ -441,18 +447,22 @@ module ActiveRecord
         filename = schema_dump_path(db_config, format)
         return unless filename
 
-        FileUtils.mkdir_p(db_dir)
-        case format.to_sym
-        when :ruby
-          File.open(filename, "w:utf-8") do |file|
-            ActiveRecord::SchemaDumper.dump(migration_connection_pool, file)
-          end
-        when :sql
-          structure_dump(db_config, filename)
-          if migration_connection_pool.schema_migration.table_exists?
-            File.open(filename, "a") do |f|
-              f.puts migration_connection.dump_schema_versions
-              f.print "\n"
+        with_temporary_pool(db_config) do |pool|
+          FileUtils.mkdir_p(db_dir)
+          case format.to_sym
+          when :ruby
+            File.open(filename, "w:utf-8") do |file|
+              ActiveRecord::SchemaDumper.dump(pool, file)
+            end
+          when :sql
+            structure_dump(db_config, filename)
+            if pool.schema_migration.table_exists?
+              File.open(filename, "a") do |f|
+                pool.with_connection do |connection|
+                  f.puts connection.dump_schema_versions
+                end
+                f.print "\n"
+              end
             end
           end
         end

data/lib/active_record/test_databases.rb

@@ -19,10 +19,12 @@ module ActiveRecord
     def self.create_and_load_schema(i, env_name:)
       old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
 
-      ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
+      ActiveRecord::Base.configurations.configs_for(env_name: env_name, include_hidden: true).each do |db_config|
         db_config._database = "#{db_config.database}_#{i}"
 
-        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, nil)
+        if db_config.database_tasks?
+          ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, nil)
+        end
       end
     ensure
       ActiveRecord::Base.establish_connection

data/lib/rails/generators/active_record/application_record/USAGE

@@ -5,4 +5,4 @@ Example:
     `bin/rails generate application_record`
 
     This generates the base class. A test is not generated because no
-    behaviour is included in `ApplicationRecord` by default.
+    behavior is included in `ApplicationRecord` by default.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 8.1.0.beta1
+  version: 8.1.0
 platform: ruby
 authors:
 - David Heinemeier Hansson
@@ -15,28 +15,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.1.0.beta1
+        version: 8.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.1.0.beta1
+        version: 8.1.0
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.1.0.beta1
+        version: 8.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.1.0.beta1
+        version: 8.1.0
 - !ruby/object:Gem::Dependency
   name: timeout
   requirement: !ruby/object:Gem::Requirement
@@ -253,7 +253,6 @@ files:
 - lib/active_record/errors.rb
 - lib/active_record/explain.rb
 - lib/active_record/explain_registry.rb
-- lib/active_record/explain_subscriber.rb
 - lib/active_record/filter_attribute_handler.rb
 - lib/active_record/fixture_set/file.rb
 - lib/active_record/fixture_set/model_metadata.rb
@@ -337,6 +336,7 @@ files:
 - lib/active_record/signed_id.rb
 - lib/active_record/statement_cache.rb
 - lib/active_record/store.rb
+- lib/active_record/structured_event_subscriber.rb
 - lib/active_record/suppressor.rb
 - lib/active_record/table_metadata.rb
 - lib/active_record/tasks/abstract_tasks.rb
@@ -478,10 +478,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v8.1.0.beta1/activerecord/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v8.1.0.beta1/
+  changelog_uri: https://github.com/rails/rails/blob/v8.1.0/activerecord/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v8.1.0/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v8.1.0.beta1/activerecord
+  source_code_uri: https://github.com/rails/rails/tree/v8.1.0/activerecord
   rubygems_mfa_required: 'true'
 rdoc_options:
 - "--main"

data/lib/active_record/explain_subscriber.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/notifications"
-require "active_record/explain_registry"
-
-module ActiveRecord
-  class ExplainSubscriber # :nodoc:
-    def start(name, id, payload)
-      # unused
-    end
-
-    def finish(name, id, payload)
-      if ExplainRegistry.collect? && !ignore_payload?(payload)
-        ExplainRegistry.queries << payload.values_at(:sql, :binds)
-      end
-    end
-
-    # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
-    # our own EXPLAINs no matter how loopingly beautiful that would be.
-    #
-    # On the other hand, we want to monitor the performance of our real database
-    # queries, not the performance of the access to the query cache.
-    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
-    EXPLAINED_SQLS = /\A\s*(\/\*.*\*\/)?\s*(with|select|update|delete|insert)\b/i
-    def ignore_payload?(payload)
-      payload[:exception] ||
-        payload[:cached] ||
-        IGNORED_PAYLOADS.include?(payload[:name]) ||
-        !payload[:sql].match?(EXPLAINED_SQLS)
-    end
-
-    ActiveSupport::Notifications.subscribe("sql.active_record", new)
-  end
-end