Lazily build ActiveRecord::Result#column_types

Given this attribute is very rarely accessed, delaying as many
computations as possible is preferable.

Author: byroot

activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -175,13 +175,14 @@ def cast_result(result)
               return ActiveRecord::Result.empty
             end
 
-            types = {}
             fields = result.fields
-            fields.each_with_index do |fname, i|
-              ftype = result.ftype i
-              fmod  = result.fmod i
-              types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
+            types = Array.new(fields.size)
+            fields.size.times do |index|
+              ftype = result.ftype(index)
+              fmod  = result.fmod(index)
+              types[index] = get_oid_type(ftype, fmod, fields[index])
             end
+
             ar_result = ActiveRecord::Result.new(fields, result.values, types.freeze)
             result.clear
             ar_result

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

@@ -87,11 +87,7 @@ def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notif
                 stmt.step
                 ActiveRecord::Result.empty
               else
-                types = {}
-                stmt.columns.zip(stmt.types).each_with_index do |(c, t), i|
-                  types[c] = types[i] = type_map.lookup(t)
-                end
-                ActiveRecord::Result.new(stmt.columns, stmt.to_a, types.freeze)
+                ActiveRecord::Result.new(stmt.columns, stmt.to_a, stmt.types.map { |t| type_map.lookup(t) })
               end
             else
               # Don't cache statements if they are not prepared.
@@ -104,11 +100,7 @@ def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notif
                   stmt.step
                   ActiveRecord::Result.empty
                 else
-                  types = {}
-                  stmt.columns.zip(stmt.types).each_with_index do |(c, t), i|
-                    types[c] = types[i] = type_map.lookup(t)
-                  end
-                  ActiveRecord::Result.new(stmt.columns, stmt.to_a, types.freeze)
+                  ActiveRecord::Result.new(stmt.columns, stmt.to_a, stmt.types.map { |t| type_map.lookup(t) })
                 end
               ensure
                 stmt.close

activerecord/lib/active_record/result.rb

@@ -89,7 +89,7 @@ def to_h
       alias_method :to_hash, :to_h
     end
 
-    attr_reader :columns, :rows, :column_types
+    attr_reader :columns, :rows
 
     def self.empty(async: false) # :nodoc:
       if async
@@ -105,7 +105,8 @@ def initialize(columns, rows, column_types = nil)
       @columns      = columns.each(&:-@).freeze
       @rows         = rows
       @hash_rows    = nil
-      @column_types = column_types || EMPTY_HASH
+      @column_types = column_types.freeze
+      @types_hash   = nil
       @column_indexes = nil
     end
 
@@ -154,6 +155,23 @@ def last(n = nil)
       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|
+            types[name] = types[index] = @column_types[index]
+          end
+          types.freeze
+        end
+      else
+        EMPTY_HASH
+      end
+    end
+
     def result # :nodoc:
       self
     end
@@ -162,7 +180,7 @@ def cancel # :nodoc:
       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
 
@@ -196,15 +214,16 @@ def initialize_copy(other)
 
     def freeze # :nodoc:
       hash_rows.freeze
-      indexed_rows.freeze
+      indexed_rows
+      column_types
       super
     end
 
     def column_indexes # :nodoc:
       @column_indexes ||= begin
         index = 0
         hash = {}
-        length  = columns.length
+        length = columns.length
         while index < length
           hash[columns[index]] = index
           index += 1
@@ -222,10 +241,14 @@ def indexed_rows # :nodoc:
 
     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
 

activerecord/test/cases/result_test.rb

@@ -83,7 +83,7 @@ def result
     test "cast_values returns rows after type casting" do
       values = [["1.1", "2.2"], ["3.3", "4.4"]]
       columns = ["col1", "col2"]
-      types = { "col1" => Type::Integer.new, "col2" => Type::Float.new }
+      types = [Type::Integer.new, Type::Float.new]
       result = Result.new(columns, values, types)
 
       assert_equal [[1, 2.2], [3, 4.4]], result.cast_values
@@ -92,7 +92,7 @@ def result
     test "cast_values uses identity type for unknown types" do
       values = [["1.1", "2.2"], ["3.3", "4.4"]]
       columns = ["col1", "col2"]
-      types = { "col1" => Type::Integer.new }
+      types = [Type::Integer.new]
       result = Result.new(columns, values, types)
 
       assert_equal [[1, "2.2"], [3, "4.4"]], result.cast_values
@@ -101,7 +101,7 @@ def result
     test "cast_values returns single dimensional array if single column" do
       values = [["1.1"], ["3.3"]]
       columns = ["col1"]
-      types = { "col1" => Type::Integer.new }
+      types = [Type::Integer.new]
       result = Result.new(columns, values, types)
 
       assert_equal [1, 3], result.cast_values
@@ -110,7 +110,7 @@ def result
     test "cast_values can receive types to use instead" do
       values = [["1.1", "2.2"], ["3.3", "4.4"]]
       columns = ["col1", "col2"]
-      types = { "col1" => Type::Integer.new, "col2" => Type::Float.new }
+      types = [Type::Integer.new, Type::Float.new]
       result = Result.new(columns, values, types)
 
       assert_equal [[1.1, 2.2], [3.3, 4.4]], result.cast_values("col1" => Type::Float.new)