activerecord 7.2.4 → 8.1.4

data/lib/active_record/statement_cache.rb

@@ -31,8 +31,11 @@ module ActiveRecord
     class Substitute; end # :nodoc:
 
     class Query # :nodoc:
-      def initialize(sql)
+      attr_reader :retryable
+
+      def initialize(sql, retryable:)
         @sql = sql
+        @retryable = retryable
       end
 
       def sql_for(binds, connection)
@@ -41,11 +44,12 @@ module ActiveRecord
     end
 
     class PartialQuery < Query # :nodoc:
-      def initialize(values)
+      def initialize(values, retryable:)
         @values = values
         @indexes = values.each_with_index.find_all { |thing, i|
           Substitute === thing
         }.map(&:last)
+        @retryable = retryable
       end
 
       def sql_for(binds, connection)
@@ -74,13 +78,13 @@ module ActiveRecord
         self
       end
 
-      def add_bind(obj)
+      def add_bind(obj, &)
         @binds << obj
         @parts << Substitute.new
         self
       end
 
-      def add_binds(binds, proc_for_binds = nil)
+      def add_binds(binds, proc_for_binds = nil, &)
         @binds.concat proc_for_binds ? binds.map(&proc_for_binds) : binds
         binds.size.times do |i|
           @parts << ", " unless i == 0
@@ -94,12 +98,12 @@ module ActiveRecord
       end
     end
 
-    def self.query(sql)
-      Query.new(sql)
+    def self.query(...)
+      Query.new(...)
     end
 
-    def self.partial_query(values)
-      PartialQuery.new(values)
+    def self.partial_query(...)
+      PartialQuery.new(...)
     end
 
     def self.partial_query_collector
@@ -133,23 +137,26 @@ module ActiveRecord
       relation = (callable || block).call Params.new
       query_builder, binds = connection.cacheable_query(self, relation.arel)
       bind_map = BindMap.new(binds)
-      new(query_builder, bind_map, relation.klass)
+      new(query_builder, bind_map, relation.model)
     end
 
-    def initialize(query_builder, bind_map, klass)
+    def initialize(query_builder, bind_map, model)
       @query_builder = query_builder
       @bind_map = bind_map
-      @klass = klass
+      @model = model
     end
 
-    def execute(params, connection, allow_retry: false, &block)
-      bind_values = bind_map.bind params
-
-      sql = query_builder.sql_for bind_values, connection
+    def execute(params, connection, async: false, &block)
+      bind_values = @bind_map.bind params
+      sql = @query_builder.sql_for bind_values, connection
 
-      klass.find_by_sql(sql, bind_values, preparable: true, allow_retry: allow_retry, &block)
+      if async
+        @model.async_find_by_sql(sql, bind_values, preparable: true, allow_retry: @query_builder.retryable, &block)
+      else
+        @model.find_by_sql(sql, bind_values, preparable: true, allow_retry: @query_builder.retryable, &block)
+      end
     rescue ::RangeError
-      []
+      async ? Promise::Complete.new([]) : []
     end
 
     def self.unsupported_value?(value)
@@ -157,8 +164,5 @@ module ActiveRecord
       when NilClass, Array, Range, Hash, Relation, Base then true
       end
     end
-
-    private
-      attr_reader :query_builder, :bind_map, :klass
   end
 end

data/lib/active_record/store.rb

@@ -25,8 +25,8 @@ module ActiveRecord
   # You can set custom coder to encode/decode your serialized attributes to/from different formats.
   # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
   #
-  # NOTE: If you are using structured database data types (e.g. PostgreSQL +hstore+/+json+, or MySQL 5.7+
-  # +json+) there is no need for the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
+  # NOTE: If you are using structured database data types (e.g. PostgreSQL +hstore+/+json+, MySQL 5.7+
+  # +json+, or SQLite 3.38+ +json+) there is no need for the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
   # Simply use {.store_accessor}[rdoc-ref:ClassMethods#store_accessor] instead to generate
   # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
   # using a symbol.
@@ -146,37 +146,45 @@ module ActiveRecord
             define_method("#{accessor_key}_changed?") do
               return false unless attribute_changed?(store_attribute)
               prev_store, new_store = changes[store_attribute]
-              prev_store&.dig(key) != new_store&.dig(key)
+              accessor = store_accessor_for(store_attribute)
+              accessor.get(prev_store, key) != accessor.get(new_store, key)
             end
 
             define_method("#{accessor_key}_change") do
               return unless attribute_changed?(store_attribute)
               prev_store, new_store = changes[store_attribute]
-              [prev_store&.dig(key), new_store&.dig(key)]
+              accessor = store_accessor_for(store_attribute)
+              prev_value, new_value = accessor.get(prev_store, key), accessor.get(new_store, key)
+              [prev_value, new_value] unless prev_value == new_value
             end
 
             define_method("#{accessor_key}_was") do
               return unless attribute_changed?(store_attribute)
               prev_store, _new_store = changes[store_attribute]
-              prev_store&.dig(key)
+              accessor = store_accessor_for(store_attribute)
+              accessor.get(prev_store, key)
             end
 
             define_method("saved_change_to_#{accessor_key}?") do
               return false unless saved_change_to_attribute?(store_attribute)
               prev_store, new_store = saved_changes[store_attribute]
-              prev_store&.dig(key) != new_store&.dig(key)
+              accessor = store_accessor_for(store_attribute)
+              accessor.get(prev_store, key) != accessor.get(new_store, key)
             end
 
             define_method("saved_change_to_#{accessor_key}") do
               return unless saved_change_to_attribute?(store_attribute)
               prev_store, new_store = saved_changes[store_attribute]
-              [prev_store&.dig(key), new_store&.dig(key)]
+              accessor = store_accessor_for(store_attribute)
+              prev_value, new_value = accessor.get(prev_store, key), accessor.get(new_store, key)
+              [prev_value, new_value] unless prev_value == new_value
             end
 
             define_method("#{accessor_key}_before_last_save") do
               return unless saved_change_to_attribute?(store_attribute)
               prev_store, _new_store = saved_changes[store_attribute]
-              prev_store&.dig(key)
+              accessor = store_accessor_for(store_attribute)
+              accessor.get(prev_store, key)
             end
           end
         end
@@ -217,43 +225,66 @@ module ActiveRecord
       end
 
       def store_accessor_for(store_attribute)
-        type_for_attribute(store_attribute).accessor
+        type_for_attribute(store_attribute).tap do |type|
+          unless type.respond_to?(:accessor)
+            raise ConfigurationError, "the column '#{store_attribute}' has not been configured as a store. Please make sure the column is declared serializable via 'ActiveRecord.store' or, if your database supports it, use a structured column type like hstore or json."
+          end
+        end.accessor
       end
 
       class HashAccessor # :nodoc:
+        def self.get(store_object, key)
+          if store_object
+            store_object[key]
+          end
+        end
+
         def self.read(object, attribute, key)
-          prepare(object, attribute)
-          object.public_send(attribute)[key]
+          store_object = prepare(object, attribute)
+          store_object[key]
         end
 
         def self.write(object, attribute, key, value)
-          prepare(object, attribute)
-          object.public_send(attribute)[key] = value if value != read(object, attribute, key)
+          store_object = prepare(object, attribute)
+          store_object[key] = value if value != store_object[key]
         end
 
         def self.prepare(object, attribute)
-          object.public_send :"#{attribute}=", {} unless object.send(attribute)
+          store_object = object.public_send(attribute)
+
+          if store_object.nil?
+            store_object = {}
+            object.public_send(:"#{attribute}=", store_object)
+          end
+
+          store_object
         end
       end
 
       class StringKeyedHashAccessor < HashAccessor # :nodoc:
+        def self.get(store_object, key)
+          super store_object, Symbol === key ? key.name : key.to_s
+        end
+
         def self.read(object, attribute, key)
-          super object, attribute, key.to_s
+          super object, attribute, Symbol === key ? key.name : key.to_s
         end
 
         def self.write(object, attribute, key, value)
-          super object, attribute, key.to_s, value
+          super object, attribute, Symbol === key ? key.name : key.to_s, value
         end
       end
 
       class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor # :nodoc:
-        def self.prepare(object, store_attribute)
-          attribute = object.send(store_attribute)
-          unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
-            attribute = IndifferentCoder.as_indifferent_hash(attribute)
-            object.public_send :"#{store_attribute}=", attribute
+        def self.prepare(object, attribute)
+          store_object = object.public_send(attribute)
+
+          unless store_object.is_a?(ActiveSupport::HashWithIndifferentAccess)
+            store_object = IndifferentCoder.as_indifferent_hash(store_object)
+            object.public_send :"#{attribute}=", store_object
           end
-          attribute
+
+          store_object
         end
       end
 

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
@@ -69,9 +54,7 @@ module ActiveRecord
 
     def predicate_builder
       if klass
-        predicate_builder = klass.predicate_builder.dup
-        predicate_builder.instance_variable_set(:@table, self)
-        predicate_builder
+        klass.predicate_builder.with(self)
       else
         PredicateBuilder.new(self)
       end
@@ -80,6 +63,6 @@ module ActiveRecord
     attr_reader :arel_table
 
     private
-      attr_reader :klass, :reflection
+      attr_reader :klass
   end
 end

data/lib/active_record/tasks/abstract_tasks.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class AbstractTasks # :nodoc:
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config)
+        @db_config = db_config
+        @configuration_hash = db_config.configuration_hash
+      end
+
+      def charset
+        connection.encoding
+      end
+
+      def collation
+        connection.collation
+      end
+
+      def check_current_protected_environment!(db_config, migration_class)
+        with_temporary_pool(db_config, migration_class) do |pool|
+          migration_context = pool.migration_context
+          current = migration_context.current_environment
+          stored  = migration_context.last_stored_environment
+
+          if migration_context.protected_environment?
+            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+          end
+
+          if stored && stored != current
+            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+          end
+        rescue ActiveRecord::NoDatabaseError
+        end
+      end
+
+      private
+        attr_reader :db_config, :configuration_hash
+
+        def connection
+          ActiveRecord::Base.lease_connection
+        end
+
+        def establish_connection(config = db_config)
+          ActiveRecord::Base.establish_connection(config)
+        end
+
+        def configuration_hash_without_database
+          configuration_hash.merge(database: nil)
+        end
+
+        def run_cmd(cmd, *args, **opts)
+          fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, opts)
+        end
+
+        def run_cmd_error(cmd, args)
+          msg = +"failed to execute:\n"
+          msg << "#{cmd} #{filter_sensitive_args(args).join(' ')}\n\n"
+          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+          msg
+        end
+
+        # The failed command is echoed back, so anything secret it was given has
+        # to be kept out of the message.
+        def filter_sensitive_args(args)
+          filtered = "--password=#{ActiveSupport::ParameterFilter::FILTERED}"
+          args.map { |arg| arg.to_s.sub(/\A--password=.+/m, filtered) }
+        end
+
+        def with_temporary_pool(db_config, migration_class, clobber: false)
+          original_db_config = migration_class.connection_db_config
+          pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)
+
+          yield pool
+        ensure
+          migration_class.connection_handler.establish_connection(original_db_config, clobber: clobber)
+        end
+    end
+  end
+end