activerecord 8.0.0.beta1 → 8.0.0.rc2

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

@@ -224,6 +224,10 @@ module ActiveRecord
           options[:using_index]
         end
 
+        def nulls_not_distinct
+          options[:nulls_not_distinct]
+        end
+
         def export_name_on_schema_dump?
           !ActiveRecord::SchemaDumper.unique_ignore_pattern.match?(name) if name
         end
@@ -317,7 +321,7 @@ module ActiveRecord
 
         # Adds a unique constraint.
         #
-        #  t.unique_constraint(:position, name: 'unique_position', deferrable: :deferred)
+        #  t.unique_constraint(:position, name: 'unique_position', deferrable: :deferred, nulls_not_distinct: true)
         #
         # See {connection.add_unique_constraint}[rdoc-ref:SchemaStatements#add_unique_constraint]
         def unique_constraint(*args)
@@ -356,15 +360,13 @@ module ActiveRecord
 
       # = Active Record PostgreSQL Adapter Alter \Table
       class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
-        attr_reader :constraint_validations, :exclusion_constraint_adds, :exclusion_constraint_drops, :unique_constraint_adds, :unique_constraint_drops
+        attr_reader :constraint_validations, :exclusion_constraint_adds, :unique_constraint_adds
 
         def initialize(td)
           super
           @constraint_validations = []
           @exclusion_constraint_adds = []
-          @exclusion_constraint_drops = []
           @unique_constraint_adds = []
-          @unique_constraint_drops = []
         end
 
         def validate_constraint(name)
@@ -375,17 +377,9 @@ module ActiveRecord
           @exclusion_constraint_adds << @td.new_exclusion_constraint_definition(expression, options)
         end
 
-        def drop_exclusion_constraint(constraint_name)
-          @exclusion_constraint_drops << constraint_name
-        end
-
         def add_unique_constraint(column_name, options)
           @unique_constraint_adds << @td.new_unique_constraint_definition(column_name, options)
         end
-
-        def drop_unique_constraint(unique_constraint_name)
-          @unique_constraint_drops << unique_constraint_name
-        end
       end
     end
   end

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

@@ -68,6 +68,7 @@ module ActiveRecord
                   "t.unique_constraint #{unique_constraint.column.inspect}"
                 ]
 
+                parts << "nulls_not_distinct: #{unique_constraint.nulls_not_distinct.inspect}" if unique_constraint.nulls_not_distinct
                 parts << "deferrable: #{unique_constraint.deferrable.inspect}" if unique_constraint.deferrable
 
                 if unique_constraint.export_name_on_schema_dump?
@@ -91,7 +92,7 @@ module ActiveRecord
               spec = { type: schema_type(column).inspect }.merge!(spec)
             end
 
-            spec[:enum_type] = "\"#{column.sql_type}\"" if column.enum?
+            spec[:enum_type] = column.sql_type.inspect if column.enum?
 
             spec
           end

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

@@ -299,6 +299,8 @@ module ActiveRecord
 
         # Returns the sequence name for a table's primary key or some other specified key.
         def default_sequence_name(table_name, pk = "id") # :nodoc:
+          return nil if pk.is_a?(Array)
+
           result = serial_sequence(table_name, pk)
           return nil unless result
           Utils.extract_schema_qualified_name(result).to_s
@@ -696,7 +698,7 @@ module ActiveRecord
           scope = quoted_scope(table_name)
 
           unique_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
-            SELECT c.conname, c.conrelid, c.conkey, c.condeferrable, c.condeferred
+            SELECT c.conname, c.conrelid, c.conkey, c.condeferrable, c.condeferred, pg_get_constraintdef(c.oid) AS constraintdef
             FROM pg_constraint c
             JOIN pg_class t ON c.conrelid = t.oid
             JOIN pg_namespace n ON n.oid = c.connamespace
@@ -709,10 +711,12 @@ module ActiveRecord
             conkey = row["conkey"].delete("{}").split(",").map(&:to_i)
             columns = column_names_from_column_numbers(row["conrelid"], conkey)
 
+            nulls_not_distinct = row["constraintdef"].start_with?("UNIQUE NULLS NOT DISTINCT")
             deferrable = extract_constraint_deferrable(row["condeferrable"], row["condeferred"])
 
             options = {
               name: row["conname"],
+              nulls_not_distinct: nulls_not_distinct,
               deferrable: deferrable
             }
 
@@ -764,15 +768,12 @@ module ActiveRecord
         def remove_exclusion_constraint(table_name, expression = nil, **options)
           excl_name_to_delete = exclusion_constraint_for!(table_name, expression: expression, **options).name
 
-          at = create_alter_table(table_name)
-          at.drop_exclusion_constraint(excl_name_to_delete)
-
-          execute schema_creation.accept(at)
+          remove_constraint(table_name, excl_name_to_delete)
         end
 
         # Adds a new unique constraint to the table.
         #
-        #   add_unique_constraint :sections, [:position], deferrable: :deferred, name: "unique_position"
+        #   add_unique_constraint :sections, [:position], deferrable: :deferred, name: "unique_position", nulls_not_distinct: true
         #
         # generates:
         #
@@ -789,6 +790,9 @@ module ActiveRecord
         #   Specify whether or not the unique constraint should be deferrable. Valid values are +false+ or +:immediate+ or +:deferred+ to specify the default behavior. Defaults to +false+.
         # [<tt>:using_index</tt>]
         #   To specify an existing unique index name. Defaults to +nil+.
+        # [<tt>:nulls_not_distinct</tt>]
+        #   Create a unique constraint where NULLs are treated equally.
+        #   Note: only supported by PostgreSQL version 15.0.0 and greater.
         def add_unique_constraint(table_name, column_name = nil, **options)
           options = unique_constraint_options(table_name, column_name, options)
           at = create_alter_table(table_name)
@@ -819,10 +823,7 @@ module ActiveRecord
         def remove_unique_constraint(table_name, column_name = nil, **options)
           unique_name_to_delete = unique_constraint_for!(table_name, column: column_name, **options).name
 
-          at = create_alter_table(table_name)
-          at.drop_unique_constraint(unique_name_to_delete)
-
-          execute schema_creation.accept(at)
+          remove_constraint(table_name, unique_name_to_delete)
         end
 
         # Maps logical Rails types to PostgreSQL-specific data types.

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -575,10 +575,12 @@ module ActiveRecord
       end
 
       # Rename an existing enum type to something else.
-      def rename_enum(name, **options)
-        to = options.fetch(:to) { raise ArgumentError, ":to is required" }
+      def rename_enum(name, new_name = nil, **options)
+        new_name ||= options.fetch(:to) do
+          raise ArgumentError, "rename_enum requires two from/to name positional arguments."
+        end
 
-        exec_query("ALTER TYPE #{quote_table_name(name)} RENAME TO #{to}").tap { reload_type_map }
+        exec_query("ALTER TYPE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}").tap { reload_type_map }
       end
 
       # Add enum value to an existing enum type.
@@ -586,14 +588,14 @@ module ActiveRecord
         before, after = options.values_at(:before, :after)
         sql = +"ALTER TYPE #{quote_table_name(type_name)} ADD VALUE"
         sql << " IF NOT EXISTS" if options[:if_not_exists]
-        sql << " '#{value}'"
+        sql << " #{quote(value)}"
 
         if before && after
           raise ArgumentError, "Cannot have both :before and :after at the same time"
         elsif before
-          sql << " BEFORE '#{before}'"
+          sql << " BEFORE #{quote(before)}"
         elsif after
-          sql << " AFTER '#{after}'"
+          sql << " AFTER #{quote(after)}"
         end
 
         execute(sql).tap { reload_type_map }
@@ -608,7 +610,7 @@ module ActiveRecord
         from = options.fetch(:from) { raise ArgumentError, ":from is required" }
         to = options.fetch(:to) { raise ArgumentError, ":to is required" }
 
-        execute("ALTER TYPE #{quote_table_name(type_name)} RENAME VALUE '#{from}' TO '#{to}'").tap {
+        execute("ALTER TYPE #{quote_table_name(type_name)} RENAME VALUE #{quote(from)} TO #{quote(to)}").tap {
           reload_type_map
         }
       end
@@ -671,8 +673,8 @@ module ActiveRecord
           m.register_type "int4", Type::Integer.new(limit: 4)
           m.register_type "int8", Type::Integer.new(limit: 8)
           m.register_type "oid", OID::Oid.new
-          m.register_type "float4", Type::Float.new
-          m.alias_type "float8", "float4"
+          m.register_type "float4", Type::Float.new(limit: 24)
+          m.register_type "float8", Type::Float.new
           m.register_type "text", Type::Text.new
           register_class_with_limit m, "varchar", Type::String
           m.alias_type "char", "varchar"
@@ -796,7 +798,7 @@ module ActiveRecord
 
           case exception.result.try(:error_field, PG::PG_DIAG_SQLSTATE)
           when nil
-            if exception.message.match?(/connection is closed/i)
+            if exception.message.match?(/connection is closed/i) || exception.message.match?(/no connection to the server/i)
               ConnectionNotEstablished.new(exception, connection_pool: @pool)
             elsif exception.is_a?(PG::ConnectionBad)
               # libpq message style always ends with a newline; the pg gem's internal

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

@@ -68,7 +68,7 @@ module ActiveRecord
               raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
             end
 
-            internal_execute("BEGIN #{mode} TRANSACTION", allow_retry: true, materialize_transactions: false)
+            internal_execute("BEGIN #{mode} TRANSACTION", "TRANSACTION", allow_retry: true, materialize_transactions: false)
             if isolation
               @previous_read_uncommitted = query_value("PRAGMA read_uncommitted")
               internal_execute("PRAGMA read_uncommitted=ON", "TRANSACTION", allow_retry: true, materialize_transactions: false)

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -725,8 +725,6 @@ module ActiveRecord
             end
 
             basic_structure.map do |column|
-              column = column.to_h
-
               column_name = column["name"]
 
               if collation_hash.has_key? column_name

data/lib/active_record/connection_adapters.rb

@@ -31,62 +31,6 @@ module ActiveRecord
         class_name, path_to_adapter = @adapters[adapter_name.to_s]
 
         unless class_name
-          # To provide better error messages for adapters expecting the pre-7.2 adapter registration API, we attempt
-          # to load the adapter file from the old location which was required by convention, and then raise an error
-          # describing how to upgrade the adapter to the new API.
-          legacy_adapter_path = "active_record/connection_adapters/#{adapter_name}_adapter"
-          legacy_adapter_connection_method_name = "#{adapter_name}_connection".to_sym
-
-          begin
-            require legacy_adapter_path
-            # If we reach here it means we found the found a file that may be the legacy adapter and should raise.
-            if ActiveRecord::ConnectionHandling.method_defined?(legacy_adapter_connection_method_name)
-              # If we find the connection method then we care certain it is a legacy adapter.
-              deprecation_message = <<~MSG.squish
-                Database configuration specifies '#{adapter_name}' adapter but that adapter has not been registered.
-                Rails 7.2 has changed the way Active Record database adapters are loaded. The adapter needs to be
-                updated to register itself rather than being loaded by convention.
-                Ensure that the adapter in the Gemfile is at the latest version. If it is, then the adapter may need to
-                be modified.
-                See:
-                https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters.html#method-c-register
-              MSG
-
-              exception_message = <<~MSG.squish
-                Database configuration specifies '#{adapter_name}' adapter but that adapter has not been registered.
-                Ensure that the adapter in the Gemfile is at the latest version. If it is, then the adapter may need to
-                be modified.
-              MSG
-            else
-              # If we do not find the connection method we are much less certain it is a legacy adapter. Even though the
-              # file exists in the location defined by convenntion, it does not necessarily mean that file is supposed
-              # to define the adapter the legacy way. So raise an error that explains both possibilities.
-              deprecation_message = <<~MSG.squish
-                Database configuration specifies nonexistent '#{adapter_name}' adapter.
-                Available adapters are: #{@adapters.keys.sort.join(", ")}.
-                Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
-                adapter gem to your Gemfile if it's not in the list of available adapters.
-                Rails 7.2 has changed the way Active Record database adapters are loaded. Ensure that the adapter in
-                the Gemfile is at the latest version. If it is up to date, the adapter may need to be modified.
-                See:
-                https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters.html#method-c-register
-              MSG
-
-              exception_message = <<~MSG.squish
-                Database configuration specifies nonexistent '#{adapter_name}' adapter.
-                Available adapters are: #{@adapters.keys.sort.join(", ")}.
-                Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
-                adapter gem to your Gemfile and that it is at its latest version. If it is up to date, the adapter may
-                need to be modified.
-              MSG
-            end
-
-            ActiveRecord.deprecator.warn(deprecation_message)
-            raise AdapterNotFound, exception_message
-          rescue LoadError => error
-            # The adapter was not found in the legacy location so fall through to the error handling for a missing adapter.
-          end
-
           raise AdapterNotFound, <<~MSG.squish
             Database configuration specifies nonexistent '#{adapter_name}' adapter.
             Available adapters are: #{@adapters.keys.sort.join(", ")}.

data/lib/active_record/core.rb

@@ -103,7 +103,19 @@ module ActiveRecord
 
       class_attribute :shard_selector, instance_accessor: false, default: nil
 
-      # Specifies the attributes that will be included in the output of the #inspect method
+      ##
+      # :singleton-method:
+      #
+      # Specifies the attributes that will be included in the output of the
+      # #inspect method:
+      #
+      #   Post.attributes_for_inspect = [:id, :title]
+      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
+      #
+      # When set to `:all` inspect will list all the record's attributes:
+      #
+      #   Post.attributes_for_inspect = :all
+      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
       class_attribute :attributes_for_inspect, instance_accessor: false, default: :all
 
       def self.application_record_class? # :nodoc:
@@ -370,7 +382,7 @@ module ActiveRecord
       end
 
       def predicate_builder # :nodoc:
-        @predicate_builder ||= PredicateBuilder.new(table_metadata)
+        @predicate_builder ||= PredicateBuilder.new(TableMetadata.new(self, arel_table))
       end
 
       def type_caster # :nodoc:
@@ -415,10 +427,6 @@ module ActiveRecord
           end
         end
 
-        def table_metadata
-          TableMetadata.new(self, arel_table)
-        end
-
         def cached_find_by(keys, values)
           with_connection do |connection|
             statement = cached_find_by_statement(connection, keys) { |params|
@@ -529,12 +537,7 @@ module ActiveRecord
 
     ##
     def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.deep_dup
-      if self.class.composite_primary_key?
-        @primary_key.each { |key| @attributes.reset(key) }
-      else
-        @attributes.reset(@primary_key)
-      end
+      @attributes = init_attributes(other)
 
       _run_initialize_callbacks
 
@@ -546,6 +549,18 @@ module ActiveRecord
       super
     end
 
+    def init_attributes(_) # :nodoc:
+      attrs = @attributes.deep_dup
+
+      if self.class.composite_primary_key?
+        @primary_key.each { |key| attrs.reset(key) }
+      else
+        attrs.reset(@primary_key)
+      end
+
+      attrs
+    end
+
     # Populate +coder+ with attributes about this record that should be
     # serialized. The structure of +coder+ defined in this method is
     # guaranteed to match the structure of +coder+ passed to the #init_with
@@ -725,12 +740,26 @@ module ActiveRecord
       self.class.connection_handler
     end
 
-    # Returns the attributes specified by <tt>.attributes_for_inspect</tt> as a nicely formatted string.
+    # Returns the attributes of the record as a nicely formatted string.
+    #
+    #   Post.first.inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    #
+    # The attributes can be limited by setting <tt>.attributes_for_inspect</tt>.
+    #
+    #   Post.attributes_for_inspect = [:id, :title]
+    #   Post.first.inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!">"
     def inspect
       inspect_with_attributes(attributes_for_inspect)
     end
 
-    # Returns the full contents of the record as a nicely formatted string.
+    # Returns all attributes of the record as a nicely formatted string,
+    # ignoring <tt>.attributes_for_inspect</tt>.
+    #
+    #   Post.first.full_inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    #
     def full_inspect
       inspect_with_attributes(all_attributes_for_inspect)
     end

data/lib/active_record/database_configurations/database_config.rb

@@ -99,6 +99,10 @@ module ActiveRecord
       def use_metadata_table?
         raise NotImplementedError
       end
+
+      def seeds?
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/active_record/database_configurations/hash_config.rb

@@ -130,6 +130,14 @@ module ActiveRecord
         Base.configurations.primary?(name)
       end
 
+      # Determines whether the db:prepare task should seed the database from db/seeds.rb.
+      #
+      # If the `seeds` key is present in the config, `seeds?` will return its value.  Otherwise, it
+      # will return `true` for the primary database and `false` for all other configs.
+      def seeds?
+        configuration_hash.fetch(:seeds, primary?)
+      end
+
       # Determines whether to dump the schema/structure files and the filename that
       # should be used.
       #

data/lib/active_record/enum.rb

@@ -213,34 +213,16 @@ module ActiveRecord
         attr_reader :name, :mapping
     end
 
-    def enum(name = nil, values = nil, **options)
-      if name
-        values, options = options, {} unless values
-        return _enum(name, values, **options)
-      end
-
-      definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default, :_instance_methods)
-      options.transform_keys! { |key| :"#{key[1..-1]}" }
-
-      definitions.each { |name, values| _enum(name, values, **options) }
-
-      ActiveRecord.deprecator.warn(<<~MSG)
-        Defining enums with keyword arguments is deprecated and will be removed
-        in Rails 8.0. Positional arguments should be used instead:
-
-        #{definitions.map { |name, values| "enum :#{name}, #{values}" }.join("\n")}
-      MSG
+    def enum(name, values = nil, **options)
+      values, options = options, {} unless values
+      _enum(name, values, **options)
     end
 
     private
-      def inherited(base)
-        base.defined_enums = defined_enums.deep_dup
-        super
-      end
-
       def _enum(name, values, prefix: nil, suffix: nil, scopes: true, instance_methods: true, validate: false, **options)
         assert_valid_enum_definition_values(values)
         assert_valid_enum_options(options)
+
         # statuses = { }
         enum_values = ActiveSupport::HashWithIndifferentAccess.new
         name = name.to_s
@@ -304,6 +286,11 @@ module ActiveRecord
         enum_values.freeze
       end
 
+      def inherited(base)
+        base.defined_enums = defined_enums.deep_dup
+        super
+      end
+
       class EnumMethods < Module # :nodoc:
         def initialize(klass)
           @klass = klass

data/lib/active_record/fixtures.rb

@@ -2,7 +2,6 @@
 
 require "erb"
 require "yaml"
-require "set"
 require "active_support/dependencies"
 require "active_support/core_ext/digest/uuid"
 require "active_record/test_fixtures"

data/lib/active_record/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     MAJOR = 8
     MINOR = 0
     TINY  = 0
-    PRE   = "beta1"
+    PRE   = "rc2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/locking/optimistic.rb

@@ -9,7 +9,7 @@ module ActiveRecord
     # it was opened, an ActiveRecord::StaleObjectError exception is thrown if that has occurred
     # and the update is ignored.
     #
-    # Check out +ActiveRecord::Locking::Pessimistic+ for an alternative.
+    # Check out ActiveRecord::Locking::Pessimistic for an alternative.
     #
     # == Usage
     #

data/lib/active_record/log_subscriber.rb

@@ -126,18 +126,12 @@ module ActiveRecord
         end
       end
 
-      if Thread.respond_to?(:each_caller_location)
-        def query_source_location
-          Thread.each_caller_location do |location|
-            frame = backtrace_cleaner.clean_frame(location)
-            return frame if frame
-          end
-          nil
-        end
-      else
-        def query_source_location
-          backtrace_cleaner.clean(caller(1).lazy).first
+      def query_source_location
+        Thread.each_caller_location do |location|
+          frame = backtrace_cleaner.clean_frame(location)
+          return frame if frame
         end
+        nil
       end
 
       def filter(name, value)

data/lib/active_record/marshalling.rb

@@ -25,7 +25,10 @@ module ActiveRecord
         payload = [attributes_for_database, new_record?]
 
         cached_associations = self.class.reflect_on_all_associations.select do |reflection|
-          association_cached?(reflection.name) && association(reflection.name).loaded?
+          if association_cached?(reflection.name)
+            association = association(reflection.name)
+            association.loaded? || association.target.present?
+          end
         end
 
         unless cached_associations.empty?

data/lib/active_record/migration/command_recorder.rb

@@ -40,7 +40,7 @@ module ActiveRecord
     # * remove_reference
     # * remove_timestamps
     # * rename_column
-    # * rename_enum (must supply a +:to+ option)
+    # * rename_enum
     # * rename_enum_value (must supply a +:from+ and +:to+ option)
     # * rename_index
     # * rename_table
@@ -364,13 +364,13 @@ module ActiveRecord
         end
 
         def invert_rename_enum(args)
-          name, options = args
+          name, new_name, = args
 
-          unless options.is_a?(Hash) && options.has_key?(:to)
-            raise ActiveRecord::IrreversibleMigration, "rename_enum is only reversible if given a :to option."
+          if new_name.is_a?(Hash) && new_name.key?(:to)
+            new_name = new_name[:to]
           end
 
-          [:rename_enum, [options[:to], to: name]]
+          [:rename_enum, [new_name, name]]
         end
 
         def invert_rename_enum_value(args)

data/lib/active_record/migration.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require "active_support/core_ext/array/access"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/attribute_accessors"
@@ -679,10 +678,6 @@ module ActiveRecord
           paths = all_configs.flat_map { |config| config.migrations_paths || Migrator.migrations_paths }.uniq
           @file_watcher.new([], paths.index_with(["rb"]), &block)
         end
-
-        def connection
-          ActiveRecord::Tasks::DatabaseTasks.migration_connection
-        end
     end
 
     class << self

data/lib/active_record/model_schema.rb

@@ -276,15 +276,14 @@ module ActiveRecord
         end
 
         @table_name        = value
-        @quoted_table_name = nil
         @arel_table        = nil
         @sequence_name     = nil unless @explicit_sequence_name
         @predicate_builder = nil
       end
 
-      # Returns a quoted version of the table name, used to construct SQL statements.
+      # Returns a quoted version of the table name.
       def quoted_table_name
-        @quoted_table_name ||= adapter_class.quote_table_name(table_name)
+        adapter_class.quote_table_name(table_name)
       end
 
       # Computes the table name, (re)sets it internally, and returns it.

data/lib/active_record/query_cache.rb

@@ -43,10 +43,6 @@ module ActiveRecord
         pool.disable_query_cache!
         pool.clear_query_cache
       end
-
-      ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
-        pool.release_connection if pool.active_connection? && !pool.lease_connection.transaction_open?
-      end
     end
 
     def self.install_executor_hooks(executor = ActiveSupport::Executor)

data/lib/active_record/query_logs.rb

@@ -152,18 +152,12 @@ module ActiveRecord
         self.cached_comment = nil
       end
 
-      if Thread.respond_to?(:each_caller_location)
-        def query_source_location # :nodoc:
-          Thread.each_caller_location do |location|
-            frame = LogSubscriber.backtrace_cleaner.clean_frame(location.path)
-            return frame if frame
-          end
-          nil
-        end
-      else
-        def query_source_location # :nodoc:
-          LogSubscriber.backtrace_cleaner.clean(caller_locations(1).each).first
+      def query_source_location # :nodoc:
+        Thread.each_caller_location do |location|
+          frame = LogSubscriber.backtrace_cleaner.clean_frame(location)
+          return frame if frame
         end
+        nil
       end
 
       ActiveSupport::ExecutionContext.after_change { ActiveRecord::QueryLogs.clear_cache }

data/lib/active_record/querying.rb

@@ -86,10 +86,10 @@ module ActiveRecord
 
       message_bus.instrument("instantiation.active_record", payload) do
         if result_set.includes_column?(inheritance_column)
-          result_set.map { |record| instantiate(record, column_types, &block) }
+          result_set.indexed_rows.map { |record| instantiate(record, column_types, &block) }
         else
           # Instantiate a homogeneous set
-          result_set.map { |record| instantiate_instance_of(self, record, column_types, &block) }
+          result_set.indexed_rows.map { |record| instantiate_instance_of(self, record, column_types, &block) }
         end
       end
     end