activerecord 7.2.0 → 8.0.0.beta1

data/lib/active_record/relation.rb

@@ -68,19 +68,19 @@ module ActiveRecord
     include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches, Explain, Delegation
     include SignedId::RelationMethods, TokenFor::RelationMethods
 
-    attr_reader :table, :klass, :loaded, :predicate_builder
+    attr_reader :table, :model, :loaded, :predicate_builder
     attr_accessor :skip_preloading_value
-    alias :model :klass
+    alias :klass :model
     alias :loaded? :loaded
     alias :locked? :lock_value
 
-    def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
-      @klass  = klass
+    def initialize(model, table: model.arel_table, predicate_builder: model.predicate_builder, values: {})
+      @model  = model
       @table  = table
       @values = values
       @loaded = false
       @predicate_builder = predicate_builder
-      @delegate_to_klass = false
+      @delegate_to_model = false
       @future_result = nil
       @records = nil
       @async = false
@@ -93,7 +93,7 @@ module ActiveRecord
     end
 
     def bind_attribute(name, value) # :nodoc:
-      if reflection = klass._reflect_on_association(name)
+      if reflection = model._reflect_on_association(name)
         name = reflection.foreign_key
         value = value.read_attribute(reflection.association_primary_key) unless value.nil?
       end
@@ -430,14 +430,14 @@ module ActiveRecord
     #   Product.where("name like ?", "%Game%").cache_key(:last_reviewed_at)
     def cache_key(timestamp_column = "updated_at")
       @cache_keys ||= {}
-      @cache_keys[timestamp_column] ||= klass.collection_cache_key(self, timestamp_column)
+      @cache_keys[timestamp_column] ||= model.collection_cache_key(self, timestamp_column)
     end
 
     def compute_cache_key(timestamp_column = :updated_at) # :nodoc:
       query_signature = ActiveSupport::Digest.hexdigest(to_sql)
-      key = "#{klass.model_name.cache_key}/query-#{query_signature}"
+      key = "#{model.model_name.cache_key}/query-#{query_signature}"
 
-      if collection_cache_versioning
+      if model.collection_cache_versioning
         key
       else
         "#{key}-#{compute_cache_version(timestamp_column)}"
@@ -456,7 +456,7 @@ module ActiveRecord
     #
     #    SELECT COUNT(*), MAX("products"."updated_at") FROM "products" WHERE (name like '%Cosmic Encounter%')
     def cache_version(timestamp_column = :updated_at)
-      if collection_cache_versioning
+      if model.collection_cache_versioning
         @cache_versions ||= {}
         @cache_versions[timestamp_column] ||= compute_cache_version(timestamp_column)
       end
@@ -475,7 +475,7 @@ module ActiveRecord
 
         with_connection do |c|
           column = c.visitor.compile(table[timestamp_column])
-          select_values = "COUNT(*) AS #{adapter_class.quote_column_name("size")}, MAX(%s) AS timestamp"
+          select_values = "COUNT(*) AS #{model.adapter_class.quote_column_name("size")}, MAX(%s) AS timestamp"
 
           if collection.has_limit_or_offset?
             query = collection.select("#{column} AS collection_cache_key_timestamp")
@@ -492,7 +492,7 @@ module ActiveRecord
           size, timestamp = c.select_rows(arel, nil).first
 
           if size
-            column_type = klass.type_for_attribute(timestamp_column)
+            column_type = model.type_for_attribute(timestamp_column)
             timestamp = column_type.deserialize(timestamp)
           else
             size = 0
@@ -501,7 +501,7 @@ module ActiveRecord
       end
 
       if timestamp
-        "#{size}-#{timestamp.utc.to_fs(cache_timestamp_format)}"
+        "#{size}-#{timestamp.utc.to_fs(model.cache_timestamp_format)}"
       else
         "#{size}"
       end
@@ -532,7 +532,7 @@ module ActiveRecord
     # Please check unscoped if you want to remove all previous scopes (including
     # the default_scope) during the execution of a block.
     def scoping(all_queries: nil, &block)
-      registry = klass.scope_registry
+      registry = model.scope_registry
       if global_scope?(registry) && all_queries == false
         raise ArgumentError, "Scoping is set to apply to all queries and cannot be unset in a nested block."
       elsif already_in_scope?(registry)
@@ -543,11 +543,11 @@ module ActiveRecord
     end
 
     def _exec_scope(...) # :nodoc:
-      @delegate_to_klass = true
-      registry = klass.scope_registry
+      @delegate_to_model = true
+      registry = model.scope_registry
       _scoping(nil, registry) { instance_exec(...) || self }
     ensure
-      @delegate_to_klass = false
+      @delegate_to_model = false
     end
 
     # Updates all records in the current relation with details given. This method constructs a single SQL UPDATE
@@ -584,30 +584,30 @@ module ActiveRecord
       return 0 if @none
 
       if updates.is_a?(Hash)
-        if klass.locking_enabled? &&
-            !updates.key?(klass.locking_column) &&
-            !updates.key?(klass.locking_column.to_sym)
-          attr = table[klass.locking_column]
+        if model.locking_enabled? &&
+            !updates.key?(model.locking_column) &&
+            !updates.key?(model.locking_column.to_sym)
+          attr = table[model.locking_column]
           updates[attr.name] = _increment_attribute(attr)
         end
         values = _substitute_values(updates)
       else
-        values = Arel.sql(klass.sanitize_sql_for_assignment(updates, table.name))
+        values = Arel.sql(model.sanitize_sql_for_assignment(updates, table.name))
       end
 
-      klass.with_connection do |c|
+      model.with_connection do |c|
         arel = eager_loading? ? apply_join_dependency.arel : build_arel(c)
         arel.source.left = table
 
         group_values_arel_columns = arel_columns(group_values.uniq)
         having_clause_ast = having_clause.ast unless having_clause.empty?
-        key = if klass.composite_primary_key?
+        key = if model.composite_primary_key?
           primary_key.map { |pk| table[pk] }
         else
           table[primary_key]
         end
         stmt = arel.compile_update(values, key, having_clause_ast, group_values_arel_columns)
-        c.update(stmt, "#{klass} Update All").tap { reset }
+        c.update(stmt, "#{model} Update All").tap { reset }
       end
     end
 
@@ -615,7 +615,7 @@ module ActiveRecord
       if id == :all
         each { |record| record.update(attributes) }
       else
-        klass.update(id, attributes)
+        model.update(id, attributes)
       end
     end
 
@@ -623,7 +623,7 @@ module ActiveRecord
       if id == :all
         each { |record| record.update!(attributes) }
       else
-        klass.update!(id, attributes)
+        model.update!(id, attributes)
       end
     end
 
@@ -929,7 +929,7 @@ module ActiveRecord
         names = touch if touch != true
         names = Array.wrap(names)
         options = names.extract_options!
-        touch_updates = klass.touch_attributes_with_time(*names, **options)
+        touch_updates = model.touch_attributes_with_time(*names, **options)
         updates.merge!(touch_updates) unless touch_updates.empty?
       end
 
@@ -960,7 +960,7 @@ module ActiveRecord
     #   Person.where(name: 'David').touch_all
     #   # => "UPDATE \"people\" SET \"updated_at\" = '2018-01-04 22:55:23.132670' WHERE \"people\".\"name\" = 'David'"
     def touch_all(*names, time: nil)
-      update_all klass.touch_attributes_with_time(*names, time: time)
+      update_all model.touch_attributes_with_time(*names, time: time)
     end
 
     # Destroys the records by instantiating each
@@ -1012,20 +1012,20 @@ module ActiveRecord
         raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
       end
 
-      klass.with_connection do |c|
+      model.with_connection do |c|
         arel = eager_loading? ? apply_join_dependency.arel : build_arel(c)
         arel.source.left = table
 
         group_values_arel_columns = arel_columns(group_values.uniq)
         having_clause_ast = having_clause.ast unless having_clause.empty?
-        key = if klass.composite_primary_key?
+        key = if model.composite_primary_key?
           primary_key.map { |pk| table[pk] }
         else
           table[primary_key]
         end
         stmt = arel.compile_delete(key, having_clause_ast, group_values_arel_columns)
 
-        c.delete(stmt, "#{klass} Delete All").tap { reset }
+        c.delete(stmt, "#{model} Delete All").tap { reset }
       end
     end
 
@@ -1124,9 +1124,6 @@ module ActiveRecord
     # for queries to actually be executed concurrently. Otherwise it defaults to
     # executing them in the foreground.
     #
-    # +load_async+ will also fall back to executing in the foreground in the test environment when transactional
-    # fixtures are enabled.
-    #
     # If the query was actually executed in the background, the Active Record logs will show
     # it by prefixing the log line with <tt>ASYNC</tt>:
     #
@@ -1136,7 +1133,7 @@ module ActiveRecord
         return load if !c.async_enabled?
 
         unless loaded?
-          result = exec_main_query(async: c.current_transaction.closed?)
+          result = exec_main_query(async: !c.current_transaction.joinable?)
 
           if result.is_a?(Array)
             @records = result
@@ -1150,6 +1147,16 @@ module ActiveRecord
       self
     end
 
+    def then(&block) # :nodoc:
+      if @future_result
+        @future_result.then do
+          yield self
+        end
+      else
+        super
+      end
+    end
+
     # Returns <tt>true</tt> if the relation was scheduled on the background
     # thread pool.
     def scheduled?
@@ -1180,7 +1187,7 @@ module ActiveRecord
     def reset
       @future_result&.cancel
       @future_result = nil
-      @delegate_to_klass = false
+      @delegate_to_model = false
       @to_sql = @arel = @loaded = @should_eager_load = nil
       @offsets = @take = nil
       @cache_keys = nil
@@ -1200,7 +1207,7 @@ module ActiveRecord
           relation.to_sql
         end
       else
-        klass.with_connection do |conn|
+        model.with_connection do |conn|
           conn.unprepared_statement { conn.to_sql(arel) }
         end
       end
@@ -1210,12 +1217,12 @@ module ActiveRecord
     #
     #   User.where(name: 'Oscar').where_values_hash
     #   # => {name: "Oscar"}
-    def where_values_hash(relation_table_name = klass.table_name) # :nodoc:
+    def where_values_hash(relation_table_name = model.table_name) # :nodoc:
       where_clause.to_h(relation_table_name)
     end
 
     def scope_for_create
-      hash = where_clause.to_h(klass.table_name, equality_only: true)
+      hash = where_clause.to_h(model.table_name, equality_only: true)
       create_with_value.each { |k, v| hash[k.to_s] = v } unless create_with_value.empty?
       hash
     end
@@ -1261,6 +1268,10 @@ module ActiveRecord
       records.blank?
     end
 
+    def readonly?
+      readonly_value
+    end
+
     def values
       @values.dup
     end
@@ -1279,7 +1290,7 @@ module ActiveRecord
     end
 
     def empty_scope? # :nodoc:
-      @values == klass.unscoped.values
+      @values == model.unscoped.values
     end
 
     def has_limit_or_offset? # :nodoc:
@@ -1287,7 +1298,7 @@ module ActiveRecord
     end
 
     def alias_tracker(joins = [], aliases = nil) # :nodoc:
-      ActiveRecord::Associations::AliasTracker.create(connection_pool, table.name, joins, aliases)
+      ActiveRecord::Associations::AliasTracker.create(model.connection_pool, table.name, joins, aliases)
     end
 
     class StrictLoadingScope # :nodoc:
@@ -1317,46 +1328,46 @@ module ActiveRecord
 
     private
       def already_in_scope?(registry)
-        @delegate_to_klass && registry.current_scope(klass, true)
+        @delegate_to_model && registry.current_scope(model, true)
       end
 
       def global_scope?(registry)
-        registry.global_current_scope(klass, true)
+        registry.global_current_scope(model, true)
       end
 
       def current_scope_restoring_block(&block)
-        current_scope = klass.current_scope(true)
+        current_scope = model.current_scope(true)
         -> record do
-          klass.current_scope = current_scope
+          model.current_scope = current_scope
           yield record if block_given?
         end
       end
 
       def _new(attributes, &block)
-        klass.new(attributes, &block)
+        model.new(attributes, &block)
       end
 
       def _create(attributes, &block)
-        klass.create(attributes, &block)
+        model.create(attributes, &block)
       end
 
       def _create!(attributes, &block)
-        klass.create!(attributes, &block)
+        model.create!(attributes, &block)
       end
 
       def _scoping(scope, registry, all_queries = false)
-        previous = registry.current_scope(klass, true)
-        registry.set_current_scope(klass, scope)
+        previous = registry.current_scope(model, true)
+        registry.set_current_scope(model, scope)
 
         if all_queries
-          previous_global = registry.global_current_scope(klass, true)
-          registry.set_global_current_scope(klass, scope)
+          previous_global = registry.global_current_scope(model, true)
+          registry.set_global_current_scope(model, scope)
         end
         yield
       ensure
-        registry.set_current_scope(klass, previous)
+        registry.set_current_scope(model, previous)
         if all_queries
-          registry.set_global_current_scope(klass, previous_global)
+          registry.set_global_current_scope(model, previous_global)
         end
       end
 
@@ -1368,7 +1379,7 @@ module ActiveRecord
               value = Arel::Nodes::Grouping.new(value)
             end
           else
-            type = klass.type_for_attribute(attr.name)
+            type = model.type_for_attribute(attr.name)
             value = predicate_builder.build_bind_attribute(attr.name, type.cast(value))
           end
           [attr, value]
@@ -1415,7 +1426,7 @@ module ActiveRecord
           if where_clause.contradiction?
             [].freeze
           elsif eager_loading?
-            klass.with_connection do |c|
+            model.with_connection do |c|
               apply_join_dependency do |relation, join_dependency|
                 if relation.null_relation?
                   [].freeze
@@ -1427,8 +1438,8 @@ module ActiveRecord
               end
             end
           else
-            klass.with_connection do |c|
-              klass._query_by_sql(c, arel, async: async)
+            model.with_connection do |c|
+              model._query_by_sql(c, arel, async: async)
             end
           end
         end
@@ -1441,13 +1452,13 @@ module ActiveRecord
           @_join_dependency = nil
           records
         else
-          klass._load_from_sql(rows, &block).freeze
+          model._load_from_sql(rows, &block).freeze
         end
       end
 
       def skip_query_cache_if_necessary(&block)
         if skip_query_cache_value
-          uncached(&block)
+          model.uncached(&block)
         else
           yield
         end

data/lib/active_record/result.rb

@@ -36,6 +36,59 @@ module ActiveRecord
   class Result
     include Enumerable
 
+    class IndexedRow
+      def initialize(column_indexes, row)
+        @column_indexes = column_indexes
+        @row = row
+      end
+
+      def size
+        @column_indexes.size
+      end
+      alias_method :length, :size
+
+      def each_key(&block)
+        @column_indexes.each_key(&block)
+      end
+
+      def keys
+        @column_indexes.keys
+      end
+
+      def ==(other)
+        if other.is_a?(Hash)
+          to_hash == other
+        else
+          super
+        end
+      end
+
+      def key?(column)
+        @column_indexes.key?(column)
+      end
+
+      def fetch(column)
+        if index = @column_indexes[column]
+          @row[index]
+        elsif block_given?
+          yield
+        else
+          raise KeyError, "key not found: #{column.inspect}"
+        end
+      end
+
+      def [](column)
+        if index = @column_indexes[column]
+          @row[index]
+        end
+      end
+
+      def to_h
+        @column_indexes.transform_values { |index| @row[index] }
+      end
+      alias_method :to_hash, :to_h
+    end
+
     attr_reader :columns, :rows, :column_types
 
     def self.empty(async: false) # :nodoc:
@@ -67,14 +120,16 @@ module ActiveRecord
     end
 
     # Calls the given block once for each element in row collection, passing
-    # row as parameter.
+    # row as parameter. Each row is a Hash-like, read only object.
+    #
+    # To get real hashes, use +.to_a.each+.
     #
     # Returns an +Enumerator+ if no block is given.
     def each(&block)
       if block_given?
-        hash_rows.each(&block)
+        indexed_rows.each(&block)
       else
-        hash_rows.to_enum { @rows.size }
+        indexed_rows.to_enum { @rows.size }
       end
     end
 
@@ -134,14 +189,13 @@ module ActiveRecord
     end
 
     def initialize_copy(other)
-      @columns      = columns
-      @rows         = rows.dup
+      @rows = rows.dup
       @column_types = column_types.dup
-      @hash_rows    = nil
     end
 
     def freeze # :nodoc:
       hash_rows.freeze
+      indexed_rows.freeze
       super
     end
 
@@ -154,7 +208,7 @@ module ActiveRecord
           hash[columns[index]] = index
           index += 1
         end
-        hash
+        hash.freeze
       end
     end
 
@@ -167,6 +221,13 @@ module ActiveRecord
         end
       end
 
+      def indexed_rows
+        @indexed_rows ||= begin
+          columns = column_indexes
+          @rows.map { |row| IndexedRow.new(columns, row) }.freeze
+        end
+      end
+
       def hash_rows
         # We use transform_values to rows.
         # This is faster because we avoid any reallocs and avoid hashing entirely.

data/lib/active_record/sanitization.rb

@@ -105,12 +105,13 @@ module ActiveRecord
       #   sanitize_sql_hash_for_assignment({ status: nil, group_id: 1 }, "posts")
       #   # => "`posts`.`status` = NULL, `posts`.`group_id` = 1"
       def sanitize_sql_hash_for_assignment(attrs, table)
-        c = connection
-        attrs.map do |attr, value|
-          type = type_for_attribute(attr)
-          value = type.serialize(type.cast(value))
-          "#{c.quote_table_name_for_assignment(table, attr)} = #{c.quote(value)}"
-        end.join(", ")
+        with_connection do |c|
+          attrs.map do |attr, value|
+            type = type_for_attribute(attr)
+            value = type.serialize(type.cast(value))
+            "#{c.quote_table_name_for_assignment(table, attr)} = #{c.quote(value)}"
+          end.join(", ")
+        end
       end
 
       # Sanitizes a +string+ so that it is safe to use within an SQL

data/lib/active_record/schema_dumper.rb

@@ -63,6 +63,7 @@ module ActiveRecord
       extensions(stream)
       types(stream)
       tables(stream)
+      virtual_tables(stream)
       trailer(stream)
       stream
     end
@@ -126,6 +127,10 @@ module ActiveRecord
       def schemas(stream)
       end
 
+      # virtual tables are only supported by SQLite
+      def virtual_tables(stream)
+      end
+
       def tables(stream)
         sorted_tables = @connection.tables.sort
 

data/lib/active_record/schema_migration.rb

@@ -34,7 +34,8 @@ module ActiveRecord
     end
 
     def delete_all_versions
-      @pool.with_connection do |connection|
+      # Eagerly check in connection to avoid checking in/out many times in the called method.
+      @pool.with_connection do
         versions.each do |version|
           delete_version(version)
         end

data/lib/active_record/scoping/named.rb

@@ -23,7 +23,7 @@ module ActiveRecord
           scope = current_scope
 
           if scope
-            if self == scope.klass
+            if self == scope.model
               scope.clone
             else
               relation.merge!(scope)
@@ -190,7 +190,11 @@ module ActiveRecord
 
         private
           def singleton_method_added(name)
-            generate_relation_method(name) if Kernel.respond_to?(name) && !ActiveRecord::Relation.method_defined?(name)
+            super
+            # Most Kernel extends are both singleton and instance methods so
+            # respond_to is a fast check, but we don't want to define methods
+            # only on the module (ex. Module#name)
+            generate_relation_method(name) if Kernel.respond_to?(name) && (Kernel.method_defined?(name) || Kernel.private_method_defined?(name)) && !ActiveRecord::Relation.method_defined?(name)
           end
       end
     end

data/lib/active_record/statement_cache.rb

@@ -133,23 +133,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
+    def execute(params, connection, allow_retry: false, async: false, &block)
+      bind_values = @bind_map.bind params
+      sql = @query_builder.sql_for bind_values, connection
 
-      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: allow_retry, &block)
+      else
+        @model.find_by_sql(sql, bind_values, preparable: true, allow_retry: allow_retry, &block)
+      end
     rescue ::RangeError
-      []
+      async ? Promise.wrap([]) : []
     end
 
     def self.unsupported_value?(value)
@@ -157,8 +160,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.
@@ -217,7 +217,11 @@ 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: