activerecord 7.1.5.2 → 8.1.2.1

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:
@@ -29,6 +29,11 @@ module ActiveRecord
   #         ...
   #        ]
   #
+  #   # Get the number of rows affected by the query:
+  #   result = ActiveRecord::Base.lease_connection.exec_query('INSERT INTO posts (title, body) VALUES ("title_3", "body_3"), ("title_4", "body_4")')
+  #   result.affected_rows
+  #   # => 2
+  #
   #   # ActiveRecord::Result also includes Enumerable.
   #   result.each do |row|
   #     puts row['title'] + " " + row['body']
@@ -36,21 +41,79 @@ module ActiveRecord
   class Result
     include Enumerable
 
-    attr_reader :columns, :rows, :column_types
+    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 self.empty(async: false) # :nodoc:
+      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, :affected_rows
+
+    def self.empty(async: false, affected_rows: nil) # :nodoc:
       if async
-        EMPTY_ASYNC
+        FutureResult.wrap(new(EMPTY_ARRAY, EMPTY_ARRAY, EMPTY_HASH, affected_rows: affected_rows)).freeze
       else
-        EMPTY
+        new(EMPTY_ARRAY, EMPTY_ARRAY, EMPTY_HASH, affected_rows: affected_rows).freeze
       end
     end
 
-    def initialize(columns, rows, column_types = {})
-      @columns      = columns
+    def initialize(columns, rows, column_types = nil, affected_rows: 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.freeze
+      @types_hash   = nil
+      @column_indexes = nil
+      @affected_rows = affected_rows
     end
 
     # Returns true if this result set includes the column named +name+
@@ -64,7 +127,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)
@@ -96,6 +161,24 @@ module ActiveRecord
       n ? hash_rows.last(n) : hash_rows.last
     end
 
+    # Returns the +ActiveRecord::Type+ type of all columns.
+    # Note that not all database adapters return the result types,
+    # so the hash may be empty.
+    def column_types
+      if @column_types
+        @types_hash ||= begin
+          types = {}
+          @columns.each_with_index do |name, index|
+            type = @column_types[index] || Type.default_value
+            types[name] = types[index] = type
+          end
+          types.freeze
+        end
+      else
+        EMPTY_HASH
+      end
+    end
+
     def result # :nodoc:
       self
     end
@@ -104,7 +187,7 @@ module ActiveRecord
       self
     end
 
-    def cast_values(type_overrides = {}) # :nodoc:
+    def cast_values(type_overrides = nil) # :nodoc:
       if columns.one?
         # Separated to avoid allocating an array per row
 
@@ -131,71 +214,60 @@ module ActiveRecord
     end
 
     def initialize_copy(other)
-      @columns      = columns.dup
-      @rows         = rows.dup
-      @column_types = column_types.dup
+      @rows = rows.dup
       @hash_rows    = nil
     end
 
     def freeze # :nodoc:
       hash_rows.freeze
+      indexed_rows
+      column_types
       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
-          column_types.fetch(index) do
-            column_types.fetch(name, Type.default_value)
+        if type_overrides
+          type_overrides.fetch(name) do
+            column_type(name, index, nil)
           end
+        elsif @column_types
+          @column_types[index] || Type.default_value
+        else
+          Type.default_value
         end
       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
-      private_constant :EMPTY
-
-      EMPTY_ASYNC = FutureResult.wrap(EMPTY).freeze
-      private_constant :EMPTY_ASYNC
+      EMPTY_ARRAY = [].freeze
+      EMPTY_HASH = {}.freeze
+      private_constant :EMPTY_ARRAY, :EMPTY_HASH
   end
 end

data/lib/active_record/runtime_registry.rb

@@ -3,41 +3,64 @@
 module ActiveRecord
   # This is a thread locals registry for Active Record. For example:
   #
-  #   ActiveRecord::RuntimeRegistry.sql_runtime
+  #   ActiveRecord::RuntimeRegistry.stats.sql_runtime
   #
   # returns the connection handler local to the current unit of execution (either thread of fiber).
   module RuntimeRegistry # :nodoc:
-    extend self
+    class Stats
+      attr_accessor :sql_runtime, :async_sql_runtime, :queries_count, :cached_queries_count
+
+      def initialize
+        @sql_runtime = 0.0
+        @async_sql_runtime = 0.0
+        @queries_count = 0
+        @cached_queries_count = 0
+      end
+
+      def reset_runtimes
+        sql_runtime_was = @sql_runtime
+        @sql_runtime = 0.0
+        @async_sql_runtime = 0.0
+        sql_runtime_was
+      end
 
-    def sql_runtime
-      ActiveSupport::IsolatedExecutionState[:active_record_sql_runtime] ||= 0.0
+      public alias_method :reset, :initialize
     end
 
-    def sql_runtime=(runtime)
-      ActiveSupport::IsolatedExecutionState[:active_record_sql_runtime] = runtime
+    extend self
+
+    def call(name, start, finish, id, payload)
+      record(
+        payload[:name],
+        (finish - start) * 1_000.0,
+        cached: payload[:cached],
+        async: payload[:async],
+        lock_wait: payload[:lock_wait],
+      )
     end
 
-    def async_sql_runtime
-      ActiveSupport::IsolatedExecutionState[:active_record_async_sql_runtime] ||= 0.0
+    def record(query_name, runtime, cached: false, async: false, lock_wait: nil)
+      stats = self.stats
+
+      unless query_name == "TRANSACTION" || query_name == "SCHEMA"
+        stats.queries_count += 1
+        stats.cached_queries_count += 1 if cached
+      end
+
+      if async
+        stats.async_sql_runtime += (runtime - lock_wait)
+      end
+      stats.sql_runtime += runtime
     end
 
-    def async_sql_runtime=(runtime)
-      ActiveSupport::IsolatedExecutionState[:active_record_async_sql_runtime] = runtime
+    def stats
+      ActiveSupport::IsolatedExecutionState[:active_record_runtime] ||= Stats.new
     end
 
     def reset
-      rt, self.sql_runtime = sql_runtime, 0.0
-      self.async_sql_runtime = 0.0
-      rt
+      stats.reset
     end
   end
 end
 
-ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |name, start, finish, id, payload|
-  runtime = (finish - start) * 1_000.0
-
-  if payload[:async]
-    ActiveRecord::RuntimeRegistry.async_sql_runtime += (runtime - payload[:lock_wait])
-  end
-  ActiveRecord::RuntimeRegistry.sql_runtime += runtime
-end
+ActiveSupport::Notifications.monotonic_subscribe("sql.active_record", ActiveRecord::RuntimeRegistry)

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
@@ -160,20 +161,28 @@ module ActiveRecord
       #
       #   sanitize_sql_array(["role = ?", 0])
       #   # => "role = '0'"
+      #
+      #   Before using this method, please consider if Arel.sql would be better for your use-case
       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 +202,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