diff --git a/activerecord/lib/active_record/attribute.rb b/activerecord/lib/active_record/attribute.rb
index 91886f1324..419513fee1 100644
--- a/activerecord/lib/active_record/attribute.rb
+++ b/activerecord/lib/active_record/attribute.rb
@@ -108,7 +108,7 @@ module ActiveRecord
 
     class FromDatabase < Attribute # :nodoc:
       def type_cast(value)
-        type.type_cast_from_database(value)
+        type.deserialize(value)
       end
     end
 
diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
index 90c36e4b02..f6a9fff343 100644
--- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
+++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
@@ -2,7 +2,7 @@ module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
       class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
-        def type_cast_from_database(value)
+        def deserialize(value)
           convert_time_to_time_zone(super)
         end
 
diff --git a/activerecord/lib/active_record/attributes.rb b/activerecord/lib/active_record/attributes.rb
index 87d4bc8578..f259bfe728 100644
--- a/activerecord/lib/active_record/attributes.rb
+++ b/activerecord/lib/active_record/attributes.rb
@@ -102,7 +102,7 @@ module ActiveRecord
       #
       # Users may also define their own custom types, as long as they respond
       # to the methods defined on the value type. The method
-      # +type_cast_from_database+ or +type_cast_from_user+ will be called on
+      # +deserialize+ or +type_cast_from_user+ will be called on
       # your type object, with raw input from the database or from your
       # controllers.  See ActiveRecord::Type::Value for the expected API. It is
       # recommended that your type objects inherit from an existing type, or
@@ -143,7 +143,7 @@ module ActiveRecord
       #       @currency_converter = currency_converter
       #     end
       #
-      #     # value will be the result of +type_cast_from_database+ or
+      #     # value will be the result of +deserialize+ or
       #     # +type_cast_from_user+. Assumed to be in instance of +Money+ in
       #     # this case.
       #     def type_cast_for_database(value)
@@ -195,7 +195,7 @@ module ActiveRecord
       # Otherwise, the default will be +nil+.
       #
       # +user_provided_default+ Whether the default value should be cast using
-      # +type_cast_from_user+ or +type_cast_from_database+.
+      # +type_cast_from_user+ or +deserialize+.
       def define_attribute(
         name,
         cast_type,
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
index 932aaf7aa7..af7ef7cbaa 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_dumper.rb
@@ -47,7 +47,7 @@ module ActiveRecord
 
       def schema_default(column)
         type = lookup_cast_type_from_column(column)
-        default = type.type_cast_from_database(column.default)
+        default = type.deserialize(column.default)
         unless default.nil?
           type.type_cast_for_schema(default)
         end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
index 2608a2abab..deb2ea50a3 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
@@ -25,9 +25,9 @@ module ActiveRecord
             @delimiter = delimiter
           end
 
-          def type_cast_from_database(value)
+          def deserialize(value)
             if value.is_a?(::String)
-              type_cast_array(parse_pg_array(value), :type_cast_from_database)
+              type_cast_array(parse_pg_array(value), :deserialize)
             else
               super
             end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bytea.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bytea.rb
index 6bd1b8ecae..8f9d6e7f9b 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bytea.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bytea.rb
@@ -3,7 +3,7 @@ module ActiveRecord
     module PostgreSQL
       module OID # :nodoc:
         class Bytea < Type::Binary # :nodoc:
-          def type_cast_from_database(value)
+          def deserialize(value)
             return if value.nil?
             return value.to_s if value.is_a?(Type::Binary::Data)
             PGconn.unescape_bytea(super)
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
index b46e50c865..40bec8a3bf 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
@@ -9,7 +9,7 @@ module ActiveRecord
             :hstore
           end
 
-          def type_cast_from_database(value)
+          def deserialize(value)
             if value.is_a?(::String)
               ::Hash[value.scan(HstorePair).map { |k, v|
                 v = v.upcase == 'NULL' ? nil : v.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
index 13dd037314..27cc00b722 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
@@ -9,7 +9,7 @@ module ActiveRecord
             :json
           end
 
-          def type_cast_from_database(value)
+          def deserialize(value)
             if value.is_a?(::String)
               ::ActiveSupport::JSON.decode(value) rescue nil
             else
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb
index 380c50fc14..c761494a00 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb
@@ -13,7 +13,7 @@ module ActiveRecord
             # the comparison here. Therefore, we need to parse and re-dump the
             # raw value here to ensure the insignificant whitespaces are
             # consistent with our encoder's output.
-            raw_old_value = type_cast_for_database(type_cast_from_database(raw_old_value))
+            raw_old_value = type_cast_for_database(deserialize(raw_old_value))
             super(raw_old_value, new_value)
           end
         end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
index 9d3633d109..c4d7aaaba5 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
@@ -49,7 +49,7 @@ module ActiveRecord
           private
 
           def type_cast_single(value)
-            infinity?(value) ? value : @subtype.type_cast_from_database(value)
+            infinity?(value) ? value : @subtype.deserialize(value)
           end
 
           def type_cast_single_for_database(value)
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/uuid.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/uuid.rb
index 97b4fd3d08..98ab5fc667 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/uuid.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/uuid.rb
@@ -5,7 +5,7 @@ module ActiveRecord
         class Uuid < Type::Value # :nodoc:
           ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
 
-          alias_method :type_cast_for_database, :type_cast_from_database
+          alias_method :type_cast_for_database, :deserialize
 
           def type
             :uuid
diff --git a/activerecord/lib/active_record/enum.rb b/activerecord/lib/active_record/enum.rb
index 470e0b5d29..22b52c7347 100644
--- a/activerecord/lib/active_record/enum.rb
+++ b/activerecord/lib/active_record/enum.rb
@@ -105,7 +105,7 @@ module ActiveRecord
         end
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         return if value.nil?
         mapping.key(value.to_i)
       end
diff --git a/activerecord/lib/active_record/locking/optimistic.rb b/activerecord/lib/active_record/locking/optimistic.rb
index c5b10fcddf..a58d8355aa 100644
--- a/activerecord/lib/active_record/locking/optimistic.rb
+++ b/activerecord/lib/active_record/locking/optimistic.rb
@@ -185,7 +185,7 @@ module ActiveRecord
     end
 
     class LockingType < DelegateClass(Type::Value) # :nodoc:
-      def type_cast_from_database(value)
+      def deserialize(value)
         # `nil` *should* be changed to 0
         super.to_i
       end
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index 63e0d2fc21..4a4de86d48 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -353,9 +353,9 @@ module ActiveRecord
     def type_cast_calculated_value(value, type, operation = nil)
       case operation
         when 'count'   then value.to_i
-        when 'sum'     then type.type_cast_from_database(value || 0)
+        when 'sum'     then type.deserialize(value || 0)
         when 'average' then value.respond_to?(:to_d) ? value.to_d : value
-        else type.type_cast_from_database(value)
+        else type.deserialize(value)
       end
     end
 
diff --git a/activerecord/lib/active_record/result.rb b/activerecord/lib/active_record/result.rb
index 3a3e65ef32..500c478e65 100644
--- a/activerecord/lib/active_record/result.rb
+++ b/activerecord/lib/active_record/result.rb
@@ -81,7 +81,7 @@ module ActiveRecord
     def cast_values(type_overrides = {}) # :nodoc:
       types = columns.map { |name| column_type(name, type_overrides) }
       result = rows.map do |values|
-        types.zip(values).map { |type, value| type.type_cast_from_database(value) }
+        types.zip(values).map { |type, value| type.deserialize(value) }
       end
 
       columns.one? ? result.map!(&:first) : result
diff --git a/activerecord/lib/active_record/type/binary.rb b/activerecord/lib/active_record/type/binary.rb
index 005a48ef0d..412d387c76 100644
--- a/activerecord/lib/active_record/type/binary.rb
+++ b/activerecord/lib/active_record/type/binary.rb
@@ -23,7 +23,7 @@ module ActiveRecord
       end
 
       def changed_in_place?(raw_old_value, value)
-        old_value = type_cast_from_database(raw_old_value)
+        old_value = deserialize(raw_old_value)
         old_value != value
       end
 
diff --git a/activerecord/lib/active_record/type/helpers/mutable.rb b/activerecord/lib/active_record/type/helpers/mutable.rb
index dc37f4a885..9af39aa9fb 100644
--- a/activerecord/lib/active_record/type/helpers/mutable.rb
+++ b/activerecord/lib/active_record/type/helpers/mutable.rb
@@ -3,7 +3,7 @@ module ActiveRecord
     module Helpers
       module Mutable # :nodoc:
         def type_cast_from_user(value)
-          type_cast_from_database(type_cast_for_database(value))
+          deserialize(type_cast_for_database(value))
         end
 
         # +raw_old_value+ will be the `_before_type_cast` version of the
diff --git a/activerecord/lib/active_record/type/integer.rb b/activerecord/lib/active_record/type/integer.rb
index 2ab2402dfd..b8cbf6114d 100644
--- a/activerecord/lib/active_record/type/integer.rb
+++ b/activerecord/lib/active_record/type/integer.rb
@@ -16,7 +16,7 @@ module ActiveRecord
         :integer
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         return if value.nil?
         value.to_i
       end
diff --git a/activerecord/lib/active_record/type/serialized.rb b/activerecord/lib/active_record/type/serialized.rb
index 6c6c520048..67aac58b1d 100644
--- a/activerecord/lib/active_record/type/serialized.rb
+++ b/activerecord/lib/active_record/type/serialized.rb
@@ -11,7 +11,7 @@ module ActiveRecord
         super(subtype)
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         if default_value?(value)
           value
         else
diff --git a/activerecord/lib/active_record/type/value.rb b/activerecord/lib/active_record/type/value.rb
index 7338920f3b..d6b61ead63 100644
--- a/activerecord/lib/active_record/type/value.rb
+++ b/activerecord/lib/active_record/type/value.rb
@@ -18,7 +18,7 @@ module ActiveRecord
       # Value#type_cast and Value#cast_value.
       #
       # +value+ The raw input, as provided from the database.
-      def type_cast_from_database(value)
+      def deserialize(value)
         type_cast(value)
       end
 
@@ -73,11 +73,11 @@ module ActiveRecord
       #
       # or
       #
-      # - pass +raw_old_value+ to Value#type_cast_from_database and compare it to
+      # - pass +raw_old_value+ to Value#deserialize and compare it to
       #   +new_value+
       #
       # +raw_old_value+ The original value, before being passed to
-      # +type_cast_from_database+.
+      # +deserialize+.
       #
       # +new_value+ The current value, after type casting.
       def changed_in_place?(raw_old_value, new_value)
@@ -94,7 +94,7 @@ module ActiveRecord
       private
 
       # Convenience method. If you don't need separate behavior for
-      # Value#type_cast_from_database and Value#type_cast_from_user, you can override
+      # Value#deserialize and Value#type_cast_from_user, you can override
       # this method instead. The default behavior of both methods is to call
       # this one. See also Value#cast_value.
       def type_cast(value) # :doc:
diff --git a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
index 7d0bd24ba7..1e9eda06a5 100644
--- a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
@@ -110,7 +110,7 @@ module ActiveRecord
 
           result = @conn.exec_query('SELECT status FROM ex')
 
-          assert_equal 2, result.column_types['status'].type_cast_from_database(result.last['status'])
+          assert_equal 2, result.column_types['status'].deserialize(result.last['status'])
         end
       end
 
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index 3d5b7e5137..eaab9ad685 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -92,9 +92,9 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
   end
 
   def test_type_cast_array
-    assert_equal(['1', '2', '3'], @type.type_cast_from_database('{1,2,3}'))
-    assert_equal([], @type.type_cast_from_database('{}'))
-    assert_equal([nil], @type.type_cast_from_database('{NULL}'))
+    assert_equal(['1', '2', '3'], @type.deserialize('{1,2,3}'))
+    assert_equal([], @type.deserialize('{}'))
+    assert_equal([nil], @type.deserialize('{NULL}'))
   end
 
   def test_type_cast_integers
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index 678a476661..5079ccd059 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -40,16 +40,16 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
 
     data = "\u001F\x8B"
     assert_equal('UTF-8', data.encoding.name)
-    assert_equal('ASCII-8BIT', @type.type_cast_from_database(data).encoding.name)
+    assert_equal('ASCII-8BIT', @type.deserialize(data).encoding.name)
   end
 
   def test_type_cast_binary_value
     data = "\u001F\x8B".force_encoding("BINARY")
-    assert_equal(data, @type.type_cast_from_database(data))
+    assert_equal(data, @type.deserialize(data))
   end
 
   def test_type_case_nil
-    assert_equal(nil, @type.type_cast_from_database(nil))
+    assert_equal(nil, @type.deserialize(nil))
   end
 
   def test_read_value
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index 83dfb18e95..360f03667e 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -83,7 +83,7 @@ class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::TestCase
   class FullAddressType < ActiveRecord::Type::Value
     def type; :full_address end
 
-    def type_cast_from_database(value)
+    def deserialize(value)
       if value =~ /\("?([^",]*)"?,"?([^",]*)"?\)/
         FullAddress.new($1, $2)
       end
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index 7bf8d12eae..55ad76c8c0 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -131,7 +131,7 @@ module ActiveRecord
       name = @subscriber.payloads.last[:statement_name]
       assert name
       res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
-      plan = res.column_types['QUERY PLAN'].type_cast_from_database res.rows.first.first
+      plan = res.column_types['QUERY PLAN'].deserialize res.rows.first.first
       assert_operator plan.length, :>, 0
     end
 
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 11053a6e38..562296b7f5 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -110,10 +110,10 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_type_cast_hstore
-      assert_equal({'1' => '2'}, @type.type_cast_from_database("\"1\"=>\"2\""))
-      assert_equal({}, @type.type_cast_from_database(""))
-      assert_equal({'key'=>nil}, @type.type_cast_from_database('key => NULL'))
-      assert_equal({'c'=>'}','"a"'=>'b "a b'}, @type.type_cast_from_database(%q(c=>"}", "\"a\""=>"b \"a b")))
+      assert_equal({'1' => '2'}, @type.deserialize("\"1\"=>\"2\""))
+      assert_equal({}, @type.deserialize(""))
+      assert_equal({'key'=>nil}, @type.deserialize('key => NULL'))
+      assert_equal({'c'=>'}','"a"'=>'b "a b'}, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
     end
 
     def test_with_store_accessors
@@ -181,31 +181,31 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_parse1
-      assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @type.type_cast_from_database('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+      assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
     end
 
     def test_parse2
-      assert_equal({" " => " "},  @type.type_cast_from_database("\\ =>\\ "))
+      assert_equal({" " => " "},  @type.deserialize("\\ =>\\ "))
     end
 
     def test_parse3
-      assert_equal({"=" => ">"},  @type.type_cast_from_database("==>>"))
+      assert_equal({"=" => ">"},  @type.deserialize("==>>"))
     end
 
     def test_parse4
-      assert_equal({"=a"=>"q=w"},   @type.type_cast_from_database('\=a=>q=w'))
+      assert_equal({"=a"=>"q=w"},   @type.deserialize('\=a=>q=w'))
     end
 
     def test_parse5
-      assert_equal({"=a"=>"q=w"},   @type.type_cast_from_database('"=a"=>q\=w'))
+      assert_equal({"=a"=>"q=w"},   @type.deserialize('"=a"=>q\=w'))
     end
 
     def test_parse6
-      assert_equal({"\"a"=>"q>w"},  @type.type_cast_from_database('"\"a"=>q>w'))
+      assert_equal({"\"a"=>"q>w"},  @type.deserialize('"\"a"=>q>w'))
     end
 
     def test_parse7
-      assert_equal({"\"a"=>"q\"w"}, @type.type_cast_from_database('\"a=>q"w'))
+      assert_equal({"\"a"=>"q\"w"}, @type.deserialize('\"a=>q"w'))
     end
 
     def test_rewrite
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index 3b123f979e..d8fded16b4 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -80,13 +80,13 @@ module PostgresqlJSONSharedTestCases
     type = JsonDataType.type_for_attribute("payload")
 
     data = "{\"a_key\":\"a_value\"}"
-    hash = type.type_cast_from_database(data)
+    hash = type.deserialize(data)
     assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, type.type_cast_from_database(data))
+    assert_equal({'a_key' => 'a_value'}, type.deserialize(data))
 
-    assert_equal({}, type.type_cast_from_database("{}"))
-    assert_equal({'key'=>nil}, type.type_cast_from_database('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, type.type_cast_from_database(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({}, type.deserialize("{}"))
+    assert_equal({'key'=>nil}, type.deserialize('{"key": null}'))
+    assert_equal({'c'=>'}','"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
diff --git a/activerecord/test/cases/attribute_decorators_test.rb b/activerecord/test/cases/attribute_decorators_test.rb
index 0b96319cbd..167db8147b 100644
--- a/activerecord/test/cases/attribute_decorators_test.rb
+++ b/activerecord/test/cases/attribute_decorators_test.rb
@@ -16,7 +16,7 @@ module ActiveRecord
         "#{super} #{@decoration}"
       end
 
-      alias type_cast_from_database type_cast_from_user
+      alias deserialize type_cast_from_user
     end
 
     setup do
@@ -106,7 +106,7 @@ module ActiveRecord
         return if value.nil?
         value * 2
       end
-      alias type_cast_from_database type_cast_from_user
+      alias deserialize type_cast_from_user
     end
 
     test "decorating with a proc" do
diff --git a/activerecord/test/cases/attribute_set_test.rb b/activerecord/test/cases/attribute_set_test.rb
index 112cd2fb14..948bcd9cd9 100644
--- a/activerecord/test/cases/attribute_set_test.rb
+++ b/activerecord/test/cases/attribute_set_test.rb
@@ -156,7 +156,7 @@ module ActiveRecord
         value + " from user"
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         return if value.nil?
         value + " from database"
       end
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
index eac73e11e8..7b20fcf3e4 100644
--- a/activerecord/test/cases/attribute_test.rb
+++ b/activerecord/test/cases/attribute_test.rb
@@ -13,7 +13,7 @@ module ActiveRecord
     end
 
     test "from_database + read type casts from database" do
-      @type.expect(:type_cast_from_database, 'type cast from database', ['a value'])
+      @type.expect(:deserialize, 'type cast from database', ['a value'])
       attribute = Attribute.from_database(nil, 'a value', @type)
 
       type_cast_value = attribute.value
@@ -31,7 +31,7 @@ module ActiveRecord
     end
 
     test "reading memoizes the value" do
-      @type.expect(:type_cast_from_database, 'from the database', ['whatever'])
+      @type.expect(:deserialize, 'from the database', ['whatever'])
       attribute = Attribute.from_database(nil, 'whatever', @type)
 
       type_cast_value = attribute.value
@@ -42,7 +42,7 @@ module ActiveRecord
     end
 
     test "reading memoizes falsy values" do
-      @type.expect(:type_cast_from_database, false, ['whatever'])
+      @type.expect(:deserialize, false, ['whatever'])
       attribute = Attribute.from_database(nil, 'whatever', @type)
 
       attribute.value
@@ -58,7 +58,7 @@ module ActiveRecord
     end
 
     test "from_database + read_for_database type casts to and from database" do
-      @type.expect(:type_cast_from_database, 'read from database', ['whatever'])
+      @type.expect(:deserialize, 'read from database', ['whatever'])
       @type.expect(:type_cast_for_database, 'ready for database', ['read from database'])
       attribute = Attribute.from_database(nil, 'whatever', @type)
 
@@ -78,7 +78,7 @@ module ActiveRecord
     end
 
     test "duping dups the value" do
-      @type.expect(:type_cast_from_database, 'type cast', ['a value'])
+      @type.expect(:deserialize, 'type cast', ['a value'])
       attribute = Attribute.from_database(nil, 'a value', @type)
 
       value_from_orig = attribute.value
@@ -90,7 +90,7 @@ module ActiveRecord
     end
 
     test "duping does not dup the value if it is not dupable" do
-      @type.expect(:type_cast_from_database, false, ['a value'])
+      @type.expect(:deserialize, false, ['a value'])
       attribute = Attribute.from_database(nil, 'a value', @type)
 
       assert_same attribute.value, attribute.dup.value
@@ -106,7 +106,7 @@ module ActiveRecord
         value + " from user"
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         value + " from database"
       end
     end
diff --git a/activerecord/test/cases/attributes_test.rb b/activerecord/test/cases/attributes_test.rb
index a753e8b74e..3eb2cc4520 100644
--- a/activerecord/test/cases/attributes_test.rb
+++ b/activerecord/test/cases/attributes_test.rb
@@ -112,7 +112,7 @@ module ActiveRecord
           "from user"
         end
 
-        def type_cast_from_database(*)
+        def deserialize(*)
           "from database"
         end
       end
diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index 3cd4073a38..30c91dfdcb 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -68,8 +68,8 @@ module ActiveRecord
         five = columns.detect { |c| c.name == "five" } unless mysql
 
         assert_equal "hello", one.default
-        assert_equal true, connection.lookup_cast_type_from_column(two).type_cast_from_database(two.default)
-        assert_equal false, connection.lookup_cast_type_from_column(three).type_cast_from_database(three.default)
+        assert_equal true, connection.lookup_cast_type_from_column(two).deserialize(two.default)
+        assert_equal false, connection.lookup_cast_type_from_column(three).deserialize(three.default)
         assert_equal '1', four.default
         assert_equal "hello", five.default unless mysql
       end
diff --git a/activerecord/test/cases/migration/columns_test.rb b/activerecord/test/cases/migration/columns_test.rb
index 6f65288ac0..e5ccfe0f91 100644
--- a/activerecord/test/cases/migration/columns_test.rb
+++ b/activerecord/test/cases/migration/columns_test.rb
@@ -196,7 +196,7 @@ module ActiveRecord
 
         old_columns = connection.columns(TestModel.table_name)
         assert old_columns.find { |c|
-          default = connection.lookup_cast_type_from_column(c).type_cast_from_database(c.default)
+          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
           c.name == 'approved' && c.type == :boolean && default == true
         }
 
@@ -204,11 +204,11 @@ module ActiveRecord
         new_columns = connection.columns(TestModel.table_name)
 
         assert_not new_columns.find { |c|
-          default = connection.lookup_cast_type_from_column(c).type_cast_from_database(c.default)
+          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
           c.name == 'approved' and c.type == :boolean and default == true
         }
         assert new_columns.find { |c|
-          default = connection.lookup_cast_type_from_column(c).type_cast_from_database(c.default)
+          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
           c.name == 'approved' and c.type == :boolean and default == false
         }
         change_column :test_models, :approved, :boolean, :default => true
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index b0e40c7145..488ef8e2c0 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -92,7 +92,7 @@ class ReflectionTest < ActiveRecord::TestCase
     type = @first.type_for_attribute("attribute_that_doesnt_exist")
     object = Object.new
 
-    assert_equal object, type.type_cast_from_database(object)
+    assert_equal object, type.deserialize(object)
     assert_equal object, type.type_cast_from_user(object)
     assert_equal object, type.type_cast_for_database(object)
   end
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index c9c05b75a6..f149457315 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -254,7 +254,7 @@ module ActiveRecord
         :string
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         raise value unless value == "type cast for database"
         "type cast from database"
       end
diff --git a/activerecord/test/cases/type/string_test.rb b/activerecord/test/cases/type/string_test.rb
index 4d78f287f1..880b6e8541 100644
--- a/activerecord/test/cases/type/string_test.rb
+++ b/activerecord/test/cases/type/string_test.rb
@@ -13,7 +13,7 @@ module ActiveRecord
       s = "foo"
       type = Type::String.new
       assert_not_same s, type.type_cast_from_user(s)
-      assert_not_same s, type.type_cast_from_database(s)
+      assert_not_same s, type.deserialize(s)
     end
 
     test "string mutations are detected" do