Merge pull request rails#29869 from kamipo/make_type_map_to_private

Make `type_map` to private because it is only used in the connection adapter

Author: rafaelfranca

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -453,12 +453,6 @@ def close
         pool.checkin self
       end
 
-      def type_map # :nodoc:
-        @type_map ||= Type::TypeMap.new.tap do |mapping|
-          initialize_type_map(mapping)
-        end
-      end
-
       def column_name_for_operation(operation, node) # :nodoc:
         visitor.accept(node, collector).value
       end
@@ -486,8 +480,13 @@ def default_index_type?(index) # :nodoc:
       end
 
       private
+        def type_map
+          @type_map ||= Type::TypeMap.new.tap do |mapping|
+            initialize_type_map(mapping)
+          end
+        end
 
-        def initialize_type_map(m)
+        def initialize_type_map(m = type_map)
           register_class_with_limit m, %r(boolean)i,       Type::Boolean
           register_class_with_limit m, %r(char)i,          Type::String
           register_class_with_limit m, %r(binary)i,        Type::Binary
@@ -520,7 +519,7 @@ def initialize_type_map(m)
 
         def reload_type_map
           type_map.clear
-          initialize_type_map(type_map)
+          initialize_type_map
         end
 
         def register_class_with_limit(mapping, key, klass)

activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -547,7 +547,7 @@ def without_sql_mode(mode)
           execute("SET @@SESSION.sql_mode = #{sql_mode}")
         end
 
-        def initialize_type_map(m)
+        def initialize_type_map(m = type_map)
           super
 
           register_class_with_limit m, %r(char)i, MysqlString

activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -31,8 +31,8 @@ def run(records)
             composites.each { |row| register_composite_type(row) }
           end
 
-          def query_conditions_for_initial_load(type_map)
-            known_type_names = type_map.keys.map { |n| "'#{n}'" }
+          def query_conditions_for_initial_load
+            known_type_names = @store.keys.map { |n| "'#{n}'" }
             known_type_types = %w('r' 'e' 'd')
             <<-SQL % [known_type_names.join(", "), known_type_types.join(", ")]
               WHERE

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -218,7 +218,7 @@ def initialize(connection, logger, connection_parameters, config)
         add_pg_decoders
 
         @type_map = Type::HashLookupTypeMap.new
-        initialize_type_map(type_map)
+        initialize_type_map
         @local_tz = execute("SHOW TIME ZONE", "SCHEMA").first["TimeZone"]
         @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
       end
@@ -427,7 +427,7 @@ def translate_exception(exception, message)
 
         def get_oid_type(oid, fmod, column_name, sql_type = "".freeze)
           if !type_map.key?(oid)
-            load_additional_types(type_map, [oid])
+            load_additional_types([oid])
           end
 
           type_map.fetch(oid, fmod, sql_type) {
@@ -438,7 +438,7 @@ def get_oid_type(oid, fmod, column_name, sql_type = "".freeze)
           }
         end
 
-        def initialize_type_map(m)
+        def initialize_type_map(m = type_map)
           register_class_with_limit m, "int2", Type::Integer
           register_class_with_limit m, "int4", Type::Integer
           register_class_with_limit m, "int8", Type::Integer
@@ -505,7 +505,7 @@ def initialize_type_map(m)
             end
           end
 
-          load_additional_types(m)
+          load_additional_types
         end
 
         def extract_limit(sql_type)
@@ -554,7 +554,7 @@ def has_default_function?(default_value, default)
           !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
         end
 
-        def load_additional_types(type_map, oids = nil)
+        def load_additional_types(oids = nil)
           initializer = OID::TypeMapInitializer.new(type_map)
 
           if supports_ranges?
@@ -573,7 +573,7 @@ def load_additional_types(type_map, oids = nil)
           if oids
             query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
           else
-            query += initializer.query_conditions_for_initial_load(type_map)
+            query += initializer.query_conditions_for_initial_load
           end
 
           execute_and_clear(query, "SCHEMA", []) do |records|

activerecord/test/cases/adapters/postgresql/composite_test.rb

@@ -106,7 +106,7 @@ def serialize(value)
   def setup
     super
 
-    @connection.type_map.register_type "full_address", FullAddressType.new
+    @connection.send(:type_map).register_type "full_address", FullAddressType.new
   end
 
   def test_column

activerecord/test/cases/adapters/postgresql/type_lookup_test.rb

@@ -8,25 +8,25 @@ class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "array delimiters are looked up correctly" do
-    box_array = @connection.type_map.lookup(1020)
-    int_array = @connection.type_map.lookup(1007)
+    box_array = @connection.send(:type_map).lookup(1020)
+    int_array = @connection.send(:type_map).lookup(1007)
 
     assert_equal ";", box_array.delimiter
     assert_equal ",", int_array.delimiter
   end
 
   test "array types correctly respect registration of subtypes" do
-    int_array = @connection.type_map.lookup(1007, -1, "integer[]")
-    bigint_array = @connection.type_map.lookup(1016, -1, "bigint[]")
+    int_array = @connection.send(:type_map).lookup(1007, -1, "integer[]")
+    bigint_array = @connection.send(:type_map).lookup(1016, -1, "bigint[]")
     big_array = [123456789123456789]
 
     assert_raises(ActiveModel::RangeError) { int_array.serialize(big_array) }
     assert_equal "{123456789123456789}", @connection.type_cast(bigint_array.serialize(big_array))
   end
 
   test "range types correctly respect registration of subtypes" do
-    int_range = @connection.type_map.lookup(3904, -1, "int4range")
-    bigint_range = @connection.type_map.lookup(3926, -1, "int8range")
+    int_range = @connection.send(:type_map).lookup(3904, -1, "int4range")
+    bigint_range = @connection.send(:type_map).lookup(3926, -1, "int8range")
     big_range = 0..123456789123456789
 
     assert_raises(ActiveModel::RangeError) { int_range.serialize(big_range) }

activerecord/test/cases/connection_adapters/mysql_type_lookup_test.rb

@@ -49,7 +49,7 @@ def test_integer_types
         private
 
           def assert_lookup_type(type, lookup)
-            cast_type = @connection.type_map.lookup(lookup)
+            cast_type = @connection.send(:type_map).lookup(lookup)
             assert_equal type, cast_type.type
           end
 

activerecord/test/cases/connection_adapters/type_lookup_test.rb

@@ -82,7 +82,7 @@ def test_integer_types
         end
 
         def test_bigint_limit
-          cast_type = @connection.type_map.lookup("bigint")
+          cast_type = @connection.send(:type_map).lookup("bigint")
           if current_adapter?(:OracleAdapter)
             assert_equal 19, cast_type.limit
           else
@@ -100,7 +100,7 @@ def test_decimal_without_scale
             { decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)} }
           end.each do |expected_type, types|
             types.each do |type|
-              cast_type = @connection.type_map.lookup(type)
+              cast_type = @connection.send(:type_map).lookup(type)
 
               assert_equal expected_type, cast_type.type
               assert_equal 2, cast_type.cast(2.1)
@@ -111,7 +111,7 @@ def test_decimal_without_scale
         private
 
           def assert_lookup_type(type, lookup)
-            cast_type = @connection.type_map.lookup(lookup)
+            cast_type = @connection.send(:type_map).lookup(lookup)
             assert_equal type, cast_type.type
           end
       end

activerecord/test/cases/query_cache_test.rb

@@ -402,10 +402,8 @@ def test_query_cached_even_when_types_are_reset
       # Warm the cache
       Task.find(1)
 
-      Task.connection.type_map.clear
-
       # Preload the type cache again (so we don't have those queries issued during our assertions)
-      Task.connection.send(:initialize_type_map, Task.connection.type_map)
+      Task.connection.send(:reload_type_map)
 
       # Clear places where type information is cached
       Task.reset_column_information