activerecord 7.2.2.1 → 8.0.5

data/lib/active_record/relation.rb

@@ -68,19 +68,26 @@ 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: nil, predicate_builder: nil, values: {})
+      if table
+        predicate_builder ||= model.predicate_builder.with(TableMetadata.new(model, table))
+      else
+        table = model.arel_table
+        predicate_builder ||= model.predicate_builder
+      end
+
+      @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 +100,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
@@ -265,7 +272,12 @@ module ActiveRecord
     # such situation.
     def create_or_find_by(attributes, &block)
       with_connection do |connection|
-        transaction(requires_new: true) { create(attributes, &block) }
+        record = nil
+        transaction(requires_new: true) do
+          record = create(attributes, &block)
+          record._last_transaction_return_status || raise(ActiveRecord::Rollback)
+        end
+        record
       rescue ActiveRecord::RecordNotUnique
         if connection.transaction_open?
           where(attributes).lock.find_by!(attributes)
@@ -280,7 +292,12 @@ module ActiveRecord
     # is raised if the created record is invalid.
     def create_or_find_by!(attributes, &block)
       with_connection do |connection|
-        transaction(requires_new: true) { create!(attributes, &block) }
+        record = nil
+        transaction(requires_new: true) do
+          record = create!(attributes, &block)
+          record._last_transaction_return_status || raise(ActiveRecord::Rollback)
+        end
+        record
       rescue ActiveRecord::RecordNotUnique
         if connection.transaction_open?
           where(attributes).lock.find_by!(attributes)
@@ -290,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)
@@ -430,14 +447,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 +473,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 +492,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 +509,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 +518,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 +549,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 +560,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 +601,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 +632,7 @@ module ActiveRecord
       if id == :all
         each { |record| record.update(attributes) }
       else
-        klass.update(id, attributes)
+        model.update(id, attributes)
       end
     end
 
@@ -623,7 +640,7 @@ module ActiveRecord
       if id == :all
         each { |record| record.update!(attributes) }
       else
-        klass.update!(id, attributes)
+        model.update!(id, attributes)
       end
     end
 
@@ -813,7 +830,7 @@ module ActiveRecord
     #
     # [:returning]
     #   (PostgreSQL, SQLite3, and MariaDB only) An array of attributes to return for all successfully
-    #   inserted records, which by default is the primary key.
+    #   upserted records, which by default is the primary key.
     #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
     #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
     #   clause entirely.
@@ -929,7 +946,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
 
@@ -942,7 +959,7 @@ module ActiveRecord
     # If attribute names are passed, they are updated along with +updated_at+/+updated_on+ attributes.
     # If no time argument is passed, the current time is used as default.
     #
-    # === Examples
+    # ==== Examples
     #
     #   # Touch all records
     #   Person.all.touch_all
@@ -960,7 +977,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
@@ -993,7 +1010,7 @@ module ActiveRecord
     #
     #   Post.where(person_id: 5).where(category: ['Something', 'Else']).delete_all
     #
-    # Both calls delete the affected posts all at once with a single DELETE statement.
+    # This call deletes the affected posts all at once with a single DELETE statement.
     # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the #destroy_all method instead.
     #
@@ -1012,20 +1029,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 +1141,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 +1150,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 +1164,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 +1204,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 +1224,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 +1234,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 +1285,10 @@ module ActiveRecord
       records.blank?
     end
 
+    def readonly?
+      readonly_value
+    end
+
     def values
       @values.dup
     end
@@ -1279,7 +1307,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 +1315,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 +1345,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 +1396,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 +1443,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 +1455,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 +1469,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,7 +120,9 @@ 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)
@@ -134,14 +189,14 @@ 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 +209,14 @@ module ActiveRecord
           hash[columns[index]] = index
           index += 1
         end
-        hash
+        hash.freeze
+      end
+    end
+
+    def indexed_rows # :nodoc:
+      @indexed_rows ||= begin
+        columns = column_indexes
+        @rows.map { |row| IndexedRow.new(columns, row) }.freeze
       end
     end
 

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
 
@@ -202,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}"
@@ -272,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|