`type_cast_for_database` -> `serialize`

40 files changed, 79 insertions, 79 deletions

diff --git a/activerecord/lib/active_record/attribute.rb b/activerecord/lib/active_record/attribute.rb
index 419513fee1..0be0fc79f5 100644
--- a/activerecord/lib/active_record/attribute.rb
+++ b/activerecord/lib/active_record/attribute.rb
@@ -43,7 +43,7 @@ module ActiveRecord
     end
 
     def value_for_database
-      type.type_cast_for_database(value)
+      type.serialize(value)
     end
 
     def changed_from?(old_value)
diff --git a/activerecord/lib/active_record/attributes.rb b/activerecord/lib/active_record/attributes.rb
index f259bfe728..650712dd19 100644
--- a/activerecord/lib/active_record/attributes.rb
+++ b/activerecord/lib/active_record/attributes.rb
@@ -133,7 +133,7 @@ module ActiveRecord
       #
       # When ActiveRecord::QueryMethods#where is called, it will
       # use the type defined by the model class to convert the value to SQL,
-      # calling +type_cast_for_database+ on your type object. For example:
+      # calling +serialize+ on your type object. For example:
       #
       #   class Money < Struct.new(:amount, :currency)
       #   end
@@ -146,7 +146,7 @@ module ActiveRecord
       #     # 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)
+      #     def serialize(value)
       #       value_in_bitcoins = @currency_converter.convert_to_bitcoins(value)
       #       value_in_bitcoins.amount
       #     end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 1ac909da2e..d2840b9498 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -52,7 +52,7 @@ module ActiveRecord
       def type_cast_from_column(column, value) # :nodoc:
         if column
           type = lookup_cast_type_from_column(column)
-          type.type_cast_for_database(value)
+          type.serialize(value)
         else
           value
         end
@@ -103,7 +103,7 @@ module ActiveRecord
       end
 
       def quote_default_expression(value, column) #:nodoc:
-        value = lookup_cast_type(column.sql_type).type_cast_for_database(value)
+        value = lookup_cast_type(column.sql_type).serialize(value)
         quote(value)
       end
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
index c6cc98d002..0a1c66be1e 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -926,7 +926,7 @@ module ActiveRecord
       end
 
       class MysqlString < Type::String # :nodoc:
-        def type_cast_for_database(value)
+        def serialize(value)
           case value
           when true then "1"
           when false then "0"
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 deb2ea50a3..ca9ceff5e4 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/array.rb
@@ -40,7 +40,7 @@ module ActiveRecord
             type_cast_array(value, :type_cast_from_user)
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Array)
               cast_value_for_database(value)
             else
@@ -69,7 +69,7 @@ module ActiveRecord
               casted_values = value.map { |item| cast_value_for_database(item) }
               "{#{casted_values.join(delimiter)}}"
             else
-              quote_and_escape(subtype.type_cast_for_database(value))
+              quote_and_escape(subtype.serialize(value))
             end
           end
 
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
index 1dbb40ca1d..7b3a8de860 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/bit.rb
@@ -20,7 +20,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             Data.new(super) if value
           end
 
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/cidr.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/cidr.rb
index 222f10fa8f..eeccb09bdf 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/cidr.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/cidr.rb
@@ -18,7 +18,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if IPAddr === value
               "#{value}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
             else
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 40bec8a3bf..9270fc9f21 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/hstore.rb
@@ -21,7 +21,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Hash)
               value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(', ')
             else
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 27cc00b722..98a5968183 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/json.rb
@@ -17,7 +17,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Array) || value.is_a?(::Hash)
               ::ActiveSupport::JSON.encode(value)
             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 c761494a00..afc9383f91 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(deserialize(raw_old_value))
+            raw_old_value = serialize(deserialize(raw_old_value))
             super(raw_old_value, new_value)
           end
         end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
index 4084725ed7..44b10c94bf 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/point.rb
@@ -23,7 +23,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Array)
               "(#{number_for_point(value[0])},#{number_for_point(value[1])})"
             else
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 c4d7aaaba5..fc201f8fb9 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/range.rb
@@ -30,7 +30,7 @@ module ActiveRecord
             ::Range.new(from, to, extracted[:exclude_end])
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Range)
               from = type_cast_single_for_database(value.begin)
               to = type_cast_single_for_database(value.end)
@@ -53,7 +53,7 @@ module ActiveRecord
           end
 
           def type_cast_single_for_database(value)
-            infinity?(value) ? '' : @subtype.type_cast_for_database(value)
+            infinity?(value) ? '' : @subtype.serialize(value)
           end
 
           def extract_bounds(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 98ab5fc667..c44645acfc 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, :deserialize
+          alias_method :serialize, :deserialize
 
           def type
             :uuid
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/oid/xml.rb b/activerecord/lib/active_record/connection_adapters/postgresql/oid/xml.rb
index 334af7c598..d40d837cee 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/oid/xml.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/oid/xml.rb
@@ -7,7 +7,7 @@ module ActiveRecord
             :xml
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             return unless value
             Data.new(super)
           end
diff --git a/activerecord/lib/active_record/enum.rb b/activerecord/lib/active_record/enum.rb
index 22b52c7347..9a5db58e78 100644
--- a/activerecord/lib/active_record/enum.rb
+++ b/activerecord/lib/active_record/enum.rb
@@ -110,7 +110,7 @@ module ActiveRecord
         mapping.key(value.to_i)
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         mapping.fetch(value, value)
       end
 
diff --git a/activerecord/lib/active_record/sanitization.rb b/activerecord/lib/active_record/sanitization.rb
index 313e767dcb..c7f55ebaa1 100644
--- a/activerecord/lib/active_record/sanitization.rb
+++ b/activerecord/lib/active_record/sanitization.rb
@@ -75,7 +75,7 @@ module ActiveRecord
       def sanitize_sql_hash_for_assignment(attrs, table)
         c = connection
         attrs.map do |attr, value|
-          value = type_for_attribute(attr.to_s).type_cast_for_database(value)
+          value = type_for_attribute(attr.to_s).serialize(value)
           "#{c.quote_table_name_for_assignment(table, attr)} = #{c.quote(value)}"
         end.join(', ')
       end
diff --git a/activerecord/lib/active_record/type/binary.rb b/activerecord/lib/active_record/type/binary.rb
index 412d387c76..7d23cb5584 100644
--- a/activerecord/lib/active_record/type/binary.rb
+++ b/activerecord/lib/active_record/type/binary.rb
@@ -17,7 +17,7 @@ module ActiveRecord
         end
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         return if value.nil?
         Data.new(super)
       end
diff --git a/activerecord/lib/active_record/type/date_time.rb b/activerecord/lib/active_record/type/date_time.rb
index a25f2521bb..05d2af3808 100644
--- a/activerecord/lib/active_record/type/date_time.rb
+++ b/activerecord/lib/active_record/type/date_time.rb
@@ -10,7 +10,7 @@ module ActiveRecord
         :datetime
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         if precision && value.respond_to?(:usec)
           number_of_insignificant_digits = 6 - precision
           round_power = 10 ** number_of_insignificant_digits
diff --git a/activerecord/lib/active_record/type/float.rb b/activerecord/lib/active_record/type/float.rb
index b3928242b7..86e3c12258 100644
--- a/activerecord/lib/active_record/type/float.rb
+++ b/activerecord/lib/active_record/type/float.rb
@@ -7,7 +7,7 @@ module ActiveRecord
         :float
       end
 
-      alias type_cast_for_database type_cast
+      alias serialize type_cast
 
       private
 
diff --git a/activerecord/lib/active_record/type/helpers/mutable.rb b/activerecord/lib/active_record/type/helpers/mutable.rb
index 9af39aa9fb..94f246f567 100644
--- a/activerecord/lib/active_record/type/helpers/mutable.rb
+++ b/activerecord/lib/active_record/type/helpers/mutable.rb
@@ -3,14 +3,14 @@ module ActiveRecord
     module Helpers
       module Mutable # :nodoc:
         def type_cast_from_user(value)
-          deserialize(type_cast_for_database(value))
+          deserialize(serialize(value))
         end
 
         # +raw_old_value+ will be the `_before_type_cast` version of the
         # value (likely a string). +new_value+ will be the current, type
         # cast value.
         def changed_in_place?(raw_old_value, new_value)
-          raw_old_value != type_cast_for_database(new_value)
+          raw_old_value != serialize(new_value)
         end
       end
     end
diff --git a/activerecord/lib/active_record/type/integer.rb b/activerecord/lib/active_record/type/integer.rb
index b8cbf6114d..a3e6cb215f 100644
--- a/activerecord/lib/active_record/type/integer.rb
+++ b/activerecord/lib/active_record/type/integer.rb
@@ -21,7 +21,7 @@ module ActiveRecord
         value.to_i
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         result = type_cast(value)
         if result
           ensure_in_range(result)
diff --git a/activerecord/lib/active_record/type/serialized.rb b/activerecord/lib/active_record/type/serialized.rb
index 67aac58b1d..732029c723 100644
--- a/activerecord/lib/active_record/type/serialized.rb
+++ b/activerecord/lib/active_record/type/serialized.rb
@@ -19,7 +19,7 @@ module ActiveRecord
         end
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         return if value.nil?
         unless default_value?(value)
           super coder.dump(value)
@@ -28,7 +28,7 @@ module ActiveRecord
 
       def changed_in_place?(raw_old_value, value)
         return false if value.nil?
-        subtype.changed_in_place?(raw_old_value, type_cast_for_database(value))
+        subtype.changed_in_place?(raw_old_value, serialize(value))
       end
 
       def accessor
diff --git a/activerecord/lib/active_record/type/string.rb b/activerecord/lib/active_record/type/string.rb
index fbc0af2c5a..2662b7e874 100644
--- a/activerecord/lib/active_record/type/string.rb
+++ b/activerecord/lib/active_record/type/string.rb
@@ -11,7 +11,7 @@ module ActiveRecord
         end
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         case value
         when ::Numeric, ActiveSupport::Duration then value.to_s
         when ::String then ::String.new(value)
diff --git a/activerecord/lib/active_record/type/value.rb b/activerecord/lib/active_record/type/value.rb
index d6b61ead63..021685c4c4 100644
--- a/activerecord/lib/active_record/type/value.rb
+++ b/activerecord/lib/active_record/type/value.rb
@@ -40,7 +40,7 @@ module ActiveRecord
       # to understand. The returned value from this method should be a
       # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
       # +nil+.
-      def type_cast_for_database(value)
+      def serialize(value)
         value
       end
 
@@ -68,7 +68,7 @@ module ActiveRecord
       # which could be mutated, you should override this method. You will need
       # to either:
       #
-      # - pass +new_value+ to Value#type_cast_for_database and compare it to
+      # - pass +new_value+ to Value#serialize and compare it to
       #   +raw_old_value+
       #
       # or
diff --git a/activerecord/lib/active_record/type_caster/map.rb b/activerecord/lib/active_record/type_caster/map.rb
index 03c9e8ff83..4b1941351c 100644
--- a/activerecord/lib/active_record/type_caster/map.rb
+++ b/activerecord/lib/active_record/type_caster/map.rb
@@ -8,7 +8,7 @@ module ActiveRecord
       def type_cast_for_database(attr_name, value)
         return value if value.is_a?(Arel::Nodes::BindParam)
         type = types.type_for_attribute(attr_name.to_s)
-        type.type_cast_for_database(value)
+        type.serialize(value)
       end
 
       protected
diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb
index a766d77e88..9be4b10a55 100644
--- a/activerecord/lib/active_record/validations/uniqueness.rb
+++ b/activerecord/lib/active_record/validations/uniqueness.rb
@@ -61,7 +61,7 @@ module ActiveRecord
 
         column = klass.columns_hash[attribute_name]
         cast_type = klass.type_for_attribute(attribute_name)
-        value = cast_type.type_cast_for_database(value)
+        value = cast_type.serialize(value)
         value = klass.connection.type_cast(value)
         if value.is_a?(String) && column.limit
           value = value.to_s[0, column.limit]
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index eaab9ad685..f7552842cc 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -206,7 +206,7 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     x = PgArray.create!(tags: tags)
     x.reload
 
-    assert_equal x.tags_before_type_cast, PgArray.type_for_attribute('tags').type_cast_for_database(tags)
+    assert_equal x.tags_before_type_cast, PgArray.type_for_attribute('tags').serialize(tags)
   end
 
   def test_quoting_non_standard_delimiters
@@ -214,8 +214,8 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     comma_delim = OID::Array.new(ActiveRecord::Type::String.new, ',')
     semicolon_delim = OID::Array.new(ActiveRecord::Type::String.new, ';')
 
-    assert_equal %({"hello,",world;}), comma_delim.type_cast_for_database(strings)
-    assert_equal %({hello,;"world;"}), semicolon_delim.type_cast_for_database(strings)
+    assert_equal %({"hello,",world;}), comma_delim.serialize(strings)
+    assert_equal %({hello,;"world;"}), semicolon_delim.serialize(strings)
   end
 
   def test_mutate_array
diff --git a/activerecord/test/cases/adapters/postgresql/cidr_test.rb b/activerecord/test/cases/adapters/postgresql/cidr_test.rb
index 54b679d3ab..6cb11d17b4 100644
--- a/activerecord/test/cases/adapters/postgresql/cidr_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/cidr_test.rb
@@ -10,14 +10,14 @@ module ActiveRecord
           ip = IPAddr.new("255.0.0.0/8")
           ip2 = IPAddr.new("127.0.0.1")
 
-          assert_equal "255.0.0.0/8", type.type_cast_for_database(ip)
-          assert_equal "127.0.0.1/32", type.type_cast_for_database(ip2)
+          assert_equal "255.0.0.0/8", type.serialize(ip)
+          assert_equal "127.0.0.1/32", type.serialize(ip2)
         end
 
         test "casting does nothing with non-IPAddr objects" do
           type = OID::Cidr.new
 
-          assert_equal "foo", type.type_cast_for_database("foo")
+          assert_equal "foo", type.serialize("foo")
         end
       end
     end
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index 360f03667e..14c81f8afb 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -93,7 +93,7 @@ class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::TestCase
       value
     end
 
-    def type_cast_for_database(value)
+    def serialize(value)
       return if value.nil?
       "(#{value.city},#{value.street})"
     end
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 562296b7f5..1dad61b476 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -165,19 +165,19 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_gen1
-      assert_equal(%q(" "=>""), @type.type_cast_for_database({' '=>''}))
+      assert_equal(%q(" "=>""), @type.serialize({' '=>''}))
     end
 
     def test_gen2
-      assert_equal(%q(","=>""), @type.type_cast_for_database({','=>''}))
+      assert_equal(%q(","=>""), @type.serialize({','=>''}))
     end
 
     def test_gen3
-      assert_equal(%q("="=>""), @type.type_cast_for_database({'='=>''}))
+      assert_equal(%q("="=>""), @type.serialize({'='=>''}))
     end
 
     def test_gen4
-      assert_equal(%q(">"=>""), @type.type_cast_for_database({'>'=>''}))
+      assert_equal(%q(">"=>""), @type.serialize({'>'=>''}))
     end
 
     def test_parse1
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index 60baacf67a..e4420d9d13 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -30,13 +30,13 @@ module ActiveRecord
         def test_quote_range
           range = "1,2]'; SELECT * FROM users; --".."a"
           type = OID::Range.new(Type::Integer.new, :int8range)
-          assert_equal "'[1,0]'", @conn.quote(type.type_cast_for_database(range))
+          assert_equal "'[1,0]'", @conn.quote(type.serialize(range))
         end
 
         def test_quote_bit_string
           value = "'); SELECT * FROM users; /*\n01\n*/--"
           type = OID::Bit.new
-          assert_equal nil, @conn.quote(type.type_cast_for_database(value))
+          assert_equal nil, @conn.quote(type.serialize(value))
         end
       end
     end
diff --git a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
index 4506e874bc..c0907b8f21 100644
--- a/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/type_lookup_test.rb
@@ -18,8 +18,8 @@ class PostgresqlTypeLookupTest < ActiveRecord::TestCase
     bigint_array = @connection.type_map.lookup(1016, -1, "bigint[]")
     big_array = [123456789123456789]
 
-    assert_raises(RangeError) { int_array.type_cast_for_database(big_array) }
-    assert_equal "{123456789123456789}", bigint_array.type_cast_for_database(big_array)
+    assert_raises(RangeError) { int_array.serialize(big_array) }
+    assert_equal "{123456789123456789}", bigint_array.serialize(big_array)
   end
 
   test "range types correctly respect registration of subtypes" do
@@ -27,7 +27,7 @@ class PostgresqlTypeLookupTest < ActiveRecord::TestCase
     bigint_range = @connection.type_map.lookup(3926, -1, "int8range")
     big_range = 0..123456789123456789
 
-    assert_raises(RangeError) { int_range.type_cast_for_database(big_range) }
-    assert_equal "[0,123456789123456789]", bigint_range.type_cast_for_database(big_range)
+    assert_raises(RangeError) { int_range.serialize(big_range) }
+    assert_equal "[0,123456789123456789]", bigint_range.serialize(big_range)
   end
 end
diff --git a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
index c1d9b7c273..243f65df98 100644
--- a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
@@ -87,7 +87,7 @@ module ActiveRecord
           value = "hello".encode('ascii-8bit')
           type = Type::String.new
 
-          assert_equal "'hello'", @conn.quote(type.type_cast_for_database(value))
+          assert_equal "'hello'", @conn.quote(type.serialize(value))
         end
       end
     end
diff --git a/activerecord/test/cases/attribute_test.rb b/activerecord/test/cases/attribute_test.rb
index 7b20fcf3e4..3b888950e2 100644
--- a/activerecord/test/cases/attribute_test.rb
+++ b/activerecord/test/cases/attribute_test.rb
@@ -59,22 +59,22 @@ module ActiveRecord
 
     test "from_database + read_for_database type casts to and from database" do
       @type.expect(:deserialize, 'read from database', ['whatever'])
-      @type.expect(:type_cast_for_database, 'ready for database', ['read from database'])
+      @type.expect(:serialize, 'ready for database', ['read from database'])
       attribute = Attribute.from_database(nil, 'whatever', @type)
 
-      type_cast_for_database = attribute.value_for_database
+      serialize = attribute.value_for_database
 
-      assert_equal 'ready for database', type_cast_for_database
+      assert_equal 'ready for database', serialize
     end
 
     test "from_user + read_for_database type casts from the user to the database" do
       @type.expect(:type_cast_from_user, 'read from user', ['whatever'])
-      @type.expect(:type_cast_for_database, 'ready for database', ['read from user'])
+      @type.expect(:serialize, 'ready for database', ['read from user'])
       attribute = Attribute.from_user(nil, 'whatever', @type)
 
-      type_cast_for_database = attribute.value_for_database
+      serialize = attribute.value_for_database
 
-      assert_equal 'ready for database', type_cast_for_database
+      assert_equal 'ready for database', serialize
     end
 
     test "duping dups the value" do
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index c2573ac72b..6d8076f3fd 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -623,13 +623,13 @@ class DirtyTest < ActiveRecord::TestCase
     end
   end
 
-  test "defaults with type that implements `type_cast_for_database`" do
+  test "defaults with type that implements `serialize`" do
     type = Class.new(ActiveRecord::Type::Value) do
       def type_cast(value)
         value.to_i
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         value.to_s
       end
     end
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 488ef8e2c0..206189350f 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -94,7 +94,7 @@ class ReflectionTest < ActiveRecord::TestCase
 
     assert_equal object, type.deserialize(object)
     assert_equal object, type.type_cast_from_user(object)
-    assert_equal object, type.type_cast_for_database(object)
+    assert_equal object, type.serialize(object)
   end
 
   def test_reflection_klass_for_nested_class_name
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index f149457315..9353be1ba7 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -259,7 +259,7 @@ module ActiveRecord
         "type cast from database"
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         raise value unless value == "value from user"
         "type cast for database"
       end
diff --git a/activerecord/test/cases/type/integer_test.rb b/activerecord/test/cases/type/integer_test.rb
index 1e836f2142..a767c73cf2 100644
--- a/activerecord/test/cases/type/integer_test.rb
+++ b/activerecord/test/cases/type/integer_test.rb
@@ -43,8 +43,8 @@ module ActiveRecord
 
       test "casting booleans for database" do
         type = Type::Integer.new
-        assert_equal 1, type.type_cast_for_database(true)
-        assert_equal 0, type.type_cast_for_database(false)
+        assert_equal 1, type.serialize(true)
+        assert_equal 0, type.serialize(false)
       end
 
       test "changed?" do
@@ -60,53 +60,53 @@ module ActiveRecord
 
       test "values below int min value are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(-2147483649)
+          Integer.new.serialize(-2147483649)
         end
       end
 
       test "values above int max value are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(2147483648)
+          Integer.new.serialize(2147483648)
         end
       end
 
       test "very small numbers are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(-9999999999999999999999999999999)
+          Integer.new.serialize(-9999999999999999999999999999999)
         end
       end
 
       test "very large numbers are out of range" do
         assert_raises(::RangeError) do
-          Integer.new.type_cast_for_database(9999999999999999999999999999999)
+          Integer.new.serialize(9999999999999999999999999999999)
         end
       end
 
       test "normal numbers are in range" do
         type = Integer.new
-        assert_equal(0, type.type_cast_for_database(0))
-        assert_equal(-1, type.type_cast_for_database(-1))
-        assert_equal(1, type.type_cast_for_database(1))
+        assert_equal(0, type.serialize(0))
+        assert_equal(-1, type.serialize(-1))
+        assert_equal(1, type.serialize(1))
       end
 
       test "int max value is in range" do
-        assert_equal(2147483647, Integer.new.type_cast_for_database(2147483647))
+        assert_equal(2147483647, Integer.new.serialize(2147483647))
       end
 
       test "int min value is in range" do
-        assert_equal(-2147483648, Integer.new.type_cast_for_database(-2147483648))
+        assert_equal(-2147483648, Integer.new.serialize(-2147483648))
       end
 
       test "columns with a larger limit have larger ranges" do
         type = Integer.new(limit: 8)
 
-        assert_equal(9223372036854775807, type.type_cast_for_database(9223372036854775807))
-        assert_equal(-9223372036854775808, type.type_cast_for_database(-9223372036854775808))
+        assert_equal(9223372036854775807, type.serialize(9223372036854775807))
+        assert_equal(-9223372036854775808, type.serialize(-9223372036854775808))
         assert_raises(::RangeError) do
-          type.type_cast_for_database(-9999999999999999999999999999999)
+          type.serialize(-9999999999999999999999999999999)
         end
         assert_raises(::RangeError) do
-          type.type_cast_for_database(9999999999999999999999999999999)
+          type.serialize(9999999999999999999999999999999)
         end
       end
 
diff --git a/activerecord/test/cases/type/unsigned_integer_test.rb b/activerecord/test/cases/type/unsigned_integer_test.rb
index 4b8e2fb518..f2c910eade 100644
--- a/activerecord/test/cases/type/unsigned_integer_test.rb
+++ b/activerecord/test/cases/type/unsigned_integer_test.rb
@@ -4,12 +4,12 @@ module ActiveRecord
   module Type
     class UnsignedIntegerTest < ActiveRecord::TestCase
       test "unsigned int max value is in range" do
-        assert_equal(4294967295, UnsignedInteger.new.type_cast_for_database(4294967295))
+        assert_equal(4294967295, UnsignedInteger.new.serialize(4294967295))
       end
 
       test "minus value is out of range" do
         assert_raises(::RangeError) do
-          UnsignedInteger.new.type_cast_for_database(-1)
+          UnsignedInteger.new.serialize(-1)
         end
       end
     end
diff --git a/activerecord/test/cases/types_test.rb b/activerecord/test/cases/types_test.rb
index 34b6f2e8a5..870d348928 100644
--- a/activerecord/test/cases/types_test.rb
+++ b/activerecord/test/cases/types_test.rb
@@ -110,7 +110,7 @@ module ActiveRecord
 
       def test_attributes_which_are_invalid_for_database_can_still_be_reassigned
         type_which_cannot_go_to_the_database = Type::Value.new
-        def type_which_cannot_go_to_the_database.type_cast_for_database(*)
+        def type_which_cannot_go_to_the_database.serialize(*)
           raise
         end
         klass = Class.new(ActiveRecord::Base) do