activerecord 7.1.5.1 → 8.0.2

data/lib/active_record/result.rb

@@ -8,7 +8,7 @@ module ActiveRecord
   # {#exec_query}[rdoc-ref:ConnectionAdapters::DatabaseStatements#exec_query]
   # on any database connection adapter. For example:
   #
-  #   result = ActiveRecord::Base.connection.exec_query('SELECT id, title, body FROM posts')
+  #   result = ActiveRecord::Base.lease_connection.exec_query('SELECT id, title, body FROM posts')
   #   result # => #<ActiveRecord::Result:0xdeadbeef>
   #
   #   # Get the column names of the result:
@@ -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:
@@ -46,11 +99,14 @@ module ActiveRecord
       end
     end
 
-    def initialize(columns, rows, column_types = {})
-      @columns      = columns
+    def initialize(columns, rows, column_types = nil)
+      # We freeze the strings to prevent them getting duped when
+      # used as keys in ActiveRecord::Base's @attributes hash
+      @columns      = columns.each(&:-@).freeze
       @rows         = rows
       @hash_rows    = nil
-      @column_types = column_types
+      @column_types = column_types || EMPTY_HASH
+      @column_indexes = nil
     end
 
     # Returns true if this result set includes the column named +name+
@@ -64,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)
@@ -131,17 +189,37 @@ module ActiveRecord
     end
 
     def initialize_copy(other)
-      @columns      = columns.dup
-      @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
 
+    def column_indexes # :nodoc:
+      @column_indexes ||= begin
+        index = 0
+        hash = {}
+        length  = columns.length
+        while index < length
+          hash[columns[index]] = index
+          index += 1
+        end
+        hash.freeze
+      end
+    end
+
+    def indexed_rows # :nodoc:
+      @indexed_rows ||= begin
+        columns = column_indexes
+        @rows.map { |row| IndexedRow.new(columns, row) }.freeze
+      end
+    end
+
     private
       def column_type(name, index, type_overrides)
         type_overrides.fetch(name) do
@@ -152,47 +230,18 @@ module ActiveRecord
       end
 
       def hash_rows
-        @hash_rows ||=
-          begin
-            # We freeze the strings to prevent them getting duped when
-            # used as keys in ActiveRecord::Base's @attributes hash
-            columns = @columns.map(&:-@)
-            length  = columns.length
-            template = nil
-
-            @rows.map { |row|
-              if template
-                # We use transform_values to build subsequent rows from the
-                # hash of the first row. This is faster because we avoid any
-                # reallocs and in Ruby 2.7+ avoid hashing entirely.
-                index = -1
-                template.transform_values do
-                  row[index += 1]
-                end
-              else
-                # In the past we used Hash[columns.zip(row)]
-                #  though elegant, the verbose way is much more efficient
-                #  both time and memory wise cause it avoids a big array allocation
-                #  this method is called a lot and needs to be micro optimised
-                hash = {}
-
-                index = 0
-                while index < length
-                  hash[columns[index]] = row[index]
-                  index += 1
-                end
-
-                # It's possible to select the same column twice, in which case
-                # we can't use a template
-                template = hash if hash.length == length
-
-                hash
-              end
-            }
-          end
+        # We use transform_values to rows.
+        # This is faster because we avoid any reallocs and avoid hashing entirely.
+        @hash_rows ||= @rows.map do |row|
+          column_indexes.transform_values { |index| row[index] }
+        end
       end
 
-      EMPTY = new([].freeze, [].freeze, {}.freeze).freeze
+      empty_array = [].freeze
+      EMPTY_HASH = {}.freeze
+      private_constant :EMPTY_HASH
+
+      EMPTY = new(empty_array, empty_array, EMPTY_HASH).freeze
       private_constant :EMPTY
 
       EMPTY_ASYNC = FutureResult.wrap(EMPTY).freeze

data/lib/active_record/runtime_registry.rb

@@ -25,15 +25,54 @@ module ActiveRecord
       ActiveSupport::IsolatedExecutionState[:active_record_async_sql_runtime] = runtime
     end
 
+    def queries_count
+      ActiveSupport::IsolatedExecutionState[:active_record_queries_count] ||= 0
+    end
+
+    def queries_count=(count)
+      ActiveSupport::IsolatedExecutionState[:active_record_queries_count] = count
+    end
+
+    def cached_queries_count
+      ActiveSupport::IsolatedExecutionState[:active_record_cached_queries_count] ||= 0
+    end
+
+    def cached_queries_count=(count)
+      ActiveSupport::IsolatedExecutionState[:active_record_cached_queries_count] = count
+    end
+
     def reset
+      reset_runtimes
+      reset_queries_count
+      reset_cached_queries_count
+    end
+
+    def reset_runtimes
       rt, self.sql_runtime = sql_runtime, 0.0
       self.async_sql_runtime = 0.0
       rt
     end
+
+    def reset_queries_count
+      qc = queries_count
+      self.queries_count = 0
+      qc
+    end
+
+    def reset_cached_queries_count
+      qc = cached_queries_count
+      self.cached_queries_count = 0
+      qc
+    end
   end
 end
 
 ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |name, start, finish, id, payload|
+  unless ["SCHEMA", "TRANSACTION"].include?(payload[:name])
+    ActiveRecord::RuntimeRegistry.queries_count += 1
+    ActiveRecord::RuntimeRegistry.cached_queries_count += 1 if payload[:cached]
+  end
+
   runtime = (finish - start) * 1_000.0
 
   if payload[:async]

data/lib/active_record/sanitization.rb

@@ -17,7 +17,7 @@ module ActiveRecord
       #   sanitize_sql_for_conditions(["name='%s' and group_id='%s'", "foo'bar", 4])
       #   # => "name='foo''bar' and group_id='4'"
       #
-      # This method will NOT sanitize a SQL string since it won't contain
+      # This method will NOT sanitize an SQL string since it won't contain
       # any conditions in it and will return the string as is.
       #
       #   sanitize_sql_for_conditions("name='foo''bar' and group_id='4'")
@@ -52,7 +52,7 @@ module ActiveRecord
       #   Post.sanitize_sql_for_assignment({ name: nil, group_id: 4 })
       #   # => "`posts`.`name` = NULL, `posts`.`group_id` = 4"
       #
-      # This method will NOT sanitize a SQL string since it won't contain
+      # This method will NOT sanitize an SQL string since it won't contain
       # any conditions in it and will return the string as is.
       #
       #   sanitize_sql_for_assignment("name=NULL and group_id='4'")
@@ -85,7 +85,7 @@ module ActiveRecord
         if condition.is_a?(Array) && condition.first.to_s.include?("?")
           disallow_raw_sql!(
             [condition.first],
-            permit: connection.column_name_with_order_matcher
+            permit: adapter_class.column_name_with_order_matcher
           )
 
           # Ensure we aren't dealing with a subclass of String that might
@@ -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
@@ -163,17 +164,23 @@ module ActiveRecord
       def sanitize_sql_array(ary)
         statement, *values = ary
         if values.first.is_a?(Hash) && /:\w+/.match?(statement)
-          replace_named_bind_variables(statement, values.first)
+          with_connection do |c|
+            replace_named_bind_variables(c, statement, values.first)
+          end
         elsif statement.include?("?")
-          replace_bind_variables(statement, values)
+          with_connection do |c|
+            replace_bind_variables(c, statement, values)
+          end
         elsif statement.blank?
           statement
         else
-          statement % values.collect { |value| connection.quote_string(value.to_s) }
+          with_connection do |c|
+            statement % values.collect { |value| c.quote_string(value.to_s) }
+          end
         end
       end
 
-      def disallow_raw_sql!(args, permit: connection.column_name_matcher) # :nodoc:
+      def disallow_raw_sql!(args, permit: adapter_class.column_name_matcher) # :nodoc:
         unexpected = nil
         args.each do |arg|
           next if arg.is_a?(Symbol) || Arel.arel_node?(arg) || permit.match?(arg.to_s.strip)
@@ -193,48 +200,47 @@ module ActiveRecord
       end
 
       private
-        def replace_bind_variables(statement, values)
+        def replace_bind_variables(connection, statement, values)
           raise_if_bind_arity_mismatch(statement, statement.count("?"), values.size)
           bound = values.dup
-          c = connection
           statement.gsub(/\?/) do
-            replace_bind_variable(bound.shift, c)
+            replace_bind_variable(connection, bound.shift)
           end
         end
 
-        def replace_bind_variable(value, c = connection)
+        def replace_bind_variable(connection, value)
           if ActiveRecord::Relation === value
             value.to_sql
           else
-            quote_bound_value(value, c)
+            quote_bound_value(connection, value)
           end
         end
 
-        def replace_named_bind_variables(statement, bind_vars)
+        def replace_named_bind_variables(connection, statement, bind_vars)
           statement.gsub(/([:\\]?):([a-zA-Z]\w*)/) do |match|
-            if $1 == ":" # skip postgresql casts
+            if $1 == ":" # skip PostgreSQL casts
               match # return the whole match
             elsif $1 == "\\" # escaped literal colon
               match[1..-1] # return match with escaping backlash char removed
             elsif bind_vars.include?(match = $2.to_sym)
-              replace_bind_variable(bind_vars[match])
+              replace_bind_variable(connection, bind_vars[match])
             else
               raise PreparedStatementInvalid, "missing value for :#{match} in #{statement}"
             end
           end
         end
 
-        def quote_bound_value(value, c = connection)
+        def quote_bound_value(connection, value)
           if value.respond_to?(:map) && !value.acts_like?(:string)
             values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
             if values.empty?
-              c.quote(c.cast_bound_value(nil))
+              connection.quote(connection.cast_bound_value(nil))
             else
-              values.map! { |v| c.quote(c.cast_bound_value(v)) }.join(",")
+              values.map! { |v| connection.quote(connection.cast_bound_value(v)) }.join(",")
             end
           else
             value = value.id_for_database if value.respond_to?(:id_for_database)
-            c.quote(c.cast_bound_value(value))
+            connection.quote(connection.cast_bound_value(value))
           end
         end
 

data/lib/active_record/schema.rb

@@ -52,14 +52,16 @@ module ActiveRecord
       end
 
       def define(info, &block) # :nodoc:
-        instance_eval(&block)
+        connection_pool.with_connection do |connection|
+          instance_eval(&block)
 
-        connection.schema_migration.create_table
-        if info[:version].present?
-          connection.assume_migrated_upto_version(info[:version])
-        end
+          connection_pool.schema_migration.create_table
+          if info[:version].present?
+            connection.assume_migrated_upto_version(info[:version])
+          end
 
-        connection.internal_metadata.create_table_and_set_flags(connection.migration_context.current_environment)
+          connection_pool.internal_metadata.create_table_and_set_flags(connection_pool.migration_context.current_environment)
+        end
       end
     end
 

data/lib/active_record/schema_dumper.rb

@@ -41,8 +41,10 @@ module ActiveRecord
     cattr_accessor :unique_ignore_pattern, default: /^uniq_rails_[0-9a-f]{10}$/
 
     class << self
-      def dump(connection = ActiveRecord::Base.connection, stream = STDOUT, config = ActiveRecord::Base)
-        connection.create_schema_dumper(generate_options(config)).dump(stream)
+      def dump(pool = ActiveRecord::Base.connection_pool, stream = $stdout, config = ActiveRecord::Base)
+        pool.with_connection do |connection|
+          connection.create_schema_dumper(generate_options(config)).dump(stream)
+        end
         stream
       end
 
@@ -61,6 +63,7 @@ module ActiveRecord
       extensions(stream)
       types(stream)
       tables(stream)
+      virtual_tables(stream)
       trailer(stream)
       stream
     end
@@ -70,7 +73,7 @@ module ActiveRecord
 
       def initialize(connection, options = {})
         @connection = connection
-        @version = connection.migration_context.current_version rescue nil
+        @version = connection.pool.migration_context.current_version rescue nil
         @options = options
         @ignore_tables = [
           ActiveRecord::Base.schema_migrations_table_name,
@@ -124,18 +127,31 @@ 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
 
-        sorted_tables.each do |table_name|
-          table(table_name, stream) unless ignored?(table_name)
+        not_ignored_tables = sorted_tables.reject { |table_name| ignored?(table_name) }
+
+        not_ignored_tables.each_with_index do |table_name, index|
+          table(table_name, stream)
+          stream.puts if index < not_ignored_tables.count - 1
         end
 
         # dump foreign keys at the end to make sure all dependent tables exist.
-        if @connection.use_foreign_keys?
-          sorted_tables.each do |tbl|
-            foreign_keys(tbl, stream) unless ignored?(tbl)
+        if @connection.supports_foreign_keys?
+          foreign_keys_stream = StringIO.new
+          not_ignored_tables.each do |tbl|
+            foreign_keys(tbl, foreign_keys_stream)
           end
+
+          foreign_keys_string = foreign_keys_stream.string
+          stream.puts if foreign_keys_string.length > 0
+
+          stream.print foreign_keys_string
         end
       end
 
@@ -191,12 +207,16 @@ 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"
-          tbl.puts
+
+          if remaining
+            tbl.puts
+            tbl.print remaining.string
+          end
 
           stream.print tbl.string
         rescue => e
@@ -262,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|

data/lib/active_record/schema_migration.rb

@@ -9,29 +9,36 @@ module ActiveRecord
     class NullSchemaMigration # :nodoc:
     end
 
-    attr_reader :connection, :arel_table
+    attr_reader :arel_table
 
-    def initialize(connection)
-      @connection = connection
+    def initialize(pool)
+      @pool = pool
       @arel_table = Arel::Table.new(table_name)
     end
 
     def create_version(version)
       im = Arel::InsertManager.new(arel_table)
       im.insert(arel_table[primary_key] => version)
-      connection.insert(im, "#{self.class} Create", primary_key, version)
+      @pool.with_connection do |connection|
+        connection.insert(im, "#{self.class} Create", primary_key, version)
+      end
     end
 
     def delete_version(version)
       dm = Arel::DeleteManager.new(arel_table)
       dm.wheres = [arel_table[primary_key].eq(version)]
 
-      connection.delete(dm, "#{self.class} Destroy")
+      @pool.with_connection do |connection|
+        connection.delete(dm, "#{self.class} Destroy")
+      end
     end
 
     def delete_all_versions
-      versions.each do |version|
-        delete_version(version)
+      # 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
       end
     end
 
@@ -44,15 +51,19 @@ module ActiveRecord
     end
 
     def create_table
-      unless connection.table_exists?(table_name)
-        connection.create_table(table_name, id: false) do |t|
-          t.string :version, **connection.internal_string_options_for_primary_key
+      @pool.with_connection do |connection|
+        unless connection.table_exists?(table_name)
+          connection.create_table(table_name, id: false) do |t|
+            t.string :version, **connection.internal_string_options_for_primary_key
+          end
         end
       end
     end
 
     def drop_table
-      connection.drop_table table_name, if_exists: true
+      @pool.with_connection do |connection|
+        connection.drop_table table_name, if_exists: true
+      end
     end
 
     def normalize_migration_number(number)
@@ -68,7 +79,9 @@ module ActiveRecord
       sm.project(arel_table[primary_key])
       sm.order(arel_table[primary_key].asc)
 
-      connection.select_values(sm, "#{self.class} Load")
+      @pool.with_connection do |connection|
+        connection.select_values(sm, "#{self.class} Load")
+      end
     end
 
     def integer_versions
@@ -79,11 +92,15 @@ module ActiveRecord
       sm = Arel::SelectManager.new(arel_table)
       sm.project(*Arel::Nodes::Count.new([Arel.star]))
 
-      connection.select_values(sm, "#{self.class} Count").first
+      @pool.with_connection do |connection|
+        connection.select_values(sm, "#{self.class} Count").first
+      end
     end
 
     def table_exists?
-      connection.data_source_exists?(table_name)
+      @pool.with_connection do |connection|
+        connection.data_source_exists?(table_name)
+      end
     end
   end
 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