rm `Column#cast_type`

The type from the column is never used, except when being passed to the
attributes API. While leaving the type on the column wasn't necessarily
a bad thing, I worry that it's existence there implies that it is
something which should be used.

During the design and implementation process of the attributes API,
there have been plenty of cases where getting the "right" type object
was hard, but I had easy access to the column objects. For any
contributor who isn't intimately familiar with the intents behind the
type casting system, grabbing the type from the column might easily seem
like the "correct" thing to do.

As such, the goal of this change is to express that the column is not
something that should be used for type casting. The only places that are
"valid" (at the time of this commit) uses of acquiring a type object
from the column are fixtures (as the YAML file is going to mirror the
database more closely than the AR object), and looking up the type
during schema detection to pass to the attributes API

Many of the failing tests were removed, as they've been made obsolete
over the last year. All of the PG column tests were testing nothing
beyond polymorphism. The Mysql2 tests were duplicating the mysql tests,
since they now share a column class.

The implementation is a little hairy, and slightly verbose, but it felt
preferable to going back to 20 constructor options for the columns. If
you are git blaming to figure out wtf I was thinking with them, and have
a better idea, go for it. Just don't use a type object for this.

10 files changed, 163 insertions, 74 deletions

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 2456376d6d..2c013a074a 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -63,6 +63,17 @@ module ActiveRecord
         lookup_cast_type(column.sql_type)
       end
 
+      def fetch_type_metadata(sql_type)
+        cast_type = lookup_cast_type(sql_type)
+        SqlTypeMetadata.new(
+          sql_type: sql_type,
+          type: cast_type.type,
+          limit: cast_type.limit,
+          precision: cast_type.precision,
+          scale: cast_type.scale,
+        )
+      end
+
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(s)
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index b927cc4a8d..67c8f438e2 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -4,6 +4,7 @@ require 'bigdecimal/util'
 require 'active_record/type'
 require 'active_support/core_ext/benchmark'
 require 'active_record/connection_adapters/schema_cache'
+require 'active_record/connection_adapters/sql_type_metadata'
 require 'active_record/connection_adapters/abstract/schema_dumper'
 require 'active_record/connection_adapters/abstract/schema_creation'
 require 'monitor'
@@ -384,8 +385,8 @@ module ActiveRecord
         end
       end
 
-      def new_column(name, default, cast_type, sql_type = nil, null = true)
-        Column.new(name, default, cast_type, sql_type, null)
+      def new_column(name, default, sql_type_metadata = nil, null = true)
+        Column.new(name, default, sql_type_metadata, null)
       end
 
       def lookup_cast_type(sql_type) # :nodoc:
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 b61b717a61..5c8c4b883a 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -74,13 +74,10 @@ module ActiveRecord
       end
 
       class Column < ConnectionAdapters::Column # :nodoc:
-        attr_reader :collation, :strict, :extra
+        delegate :strict, :collation, :extra, to: :sql_type_metadata, allow_nil: true
 
-        def initialize(name, default, cast_type, sql_type = nil, null = true, collation = nil, strict = false, extra = "")
-          @strict    = strict
-          @collation = collation
-          @extra     = extra
-          super(name, default, cast_type, sql_type, null)
+        def initialize(*)
+          super
           assert_valid_default(default)
           extract_default
         end
@@ -88,7 +85,7 @@ module ActiveRecord
         def extract_default
           if blob_or_text_column?
             @default = null || strict ? nil : ''
-          elsif missing_default_forged_as_empty_string?(@default)
+          elsif missing_default_forged_as_empty_string?(default)
             @default = nil
           end
         end
@@ -106,13 +103,6 @@ module ActiveRecord
           collation && !collation.match(/_ci$/)
         end
 
-        def ==(other)
-          super &&
-            collation == other.collation &&
-            strict == other.strict &&
-            extra == other.extra
-        end
-
         private
 
         # MySQL misreports NOT NULL column default when none is given.
@@ -131,9 +121,33 @@ module ActiveRecord
             raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
           end
         end
+      end
+
+      class MysqlTypeMetadata < DelegateClass(SqlTypeMetadata) # :nodoc:
+        attr_reader :collation, :extra, :strict
+
+        def initialize(type_metadata, collation: "", extra: "", strict: false)
+          super(type_metadata)
+          @type_metadata = type_metadata
+          @collation = collation
+          @extra = extra
+          @strict = strict
+        end
+
+        def ==(other)
+          other.is_a?(MysqlTypeMetadata) &&
+            attributes_for_hash == other.attributes_for_hash
+        end
+        alias eql? ==
+
+        def hash
+          attributes_for_hash.hash
+        end
+
+        protected
 
         def attributes_for_hash
-          super + [collation, strict, extra]
+          [self.class, @type_metadata, collation, extra, strict]
         end
       end
 
@@ -243,8 +257,8 @@ module ActiveRecord
         raise NotImplementedError
       end
 
-      def new_column(field, default, cast_type, sql_type = nil, null = true, collation = "", extra = "") # :nodoc:
-        Column.new(field, default, cast_type, sql_type, null, collation, strict_mode?, extra)
+      def new_column(field, default, sql_type_metadata = nil, null = true) # :nodoc:
+        Column.new(field, default, sql_type_metadata, null)
       end
 
       # Must return the MySQL error number from the exception, if the exception has an
@@ -467,8 +481,8 @@ module ActiveRecord
           each_hash(result).map do |field|
             field_name = set_field_encoding(field[:Field])
             sql_type = field[:Type]
-            cast_type = lookup_cast_type(sql_type)
-            new_column(field_name, field[:Default], cast_type, sql_type, field[:Null] == "YES", field[:Collation], field[:Extra])
+            type_metadata = fetch_type_metadata(sql_type, field[:Collation], field[:Extra])
+            new_column(field_name, field[:Default], type_metadata, field[:Null] == "YES")
           end
         end
       end
@@ -716,6 +730,10 @@ module ActiveRecord
         end
       end
 
+      def fetch_type_metadata(sql_type, collation = "", extra = "")
+        MysqlTypeMetadata.new(super(sql_type), collation: collation, extra: extra, strict: strict_mode?)
+      end
+
       # MySQL is too stupid to create a temporary table for use subquery, so we have
       # to give it some prompting in the form of a subsubquery. Ugh!
       def subquery_for(key, select)
diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb
index 077d953ca2..fa5ed07b8a 100644
--- a/activerecord/lib/active_record/connection_adapters/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/column.rb
@@ -12,25 +12,21 @@ module ActiveRecord
         ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
       end
 
-      attr_reader :name, :cast_type, :null, :sql_type, :default, :default_function
+      attr_reader :name, :null, :sql_type_metadata, :default, :default_function
 
-      delegate :precision, :scale, :limit, :type, to: :cast_type
+      delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
 
       # Instantiates a new column in the table.
       #
       # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int(11)</tt>.
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
-      # +cast_type+ is the object used for type casting and type information.
-      # +sql_type+ is used to extract the column's length, if necessary. For example +60+ in
-      # <tt>company_name varchar(60)</tt>.
-      # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
+      # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil)
-        @name             = name
-        @cast_type        = cast_type
-        @sql_type         = sql_type
-        @null             = null
-        @default          = default
+      def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil)
+        @name = name
+        @sql_type_metadata = sql_type_metadata
+        @null = null
+        @default = default
         @default_function = default_function
       end
 
@@ -47,12 +43,8 @@ module ActiveRecord
       end
 
       def ==(other)
-        other.name == name &&
-          other.default == default &&
-          other.cast_type == cast_type &&
-          other.sql_type == sql_type &&
-          other.null == null &&
-          other.default_function == default_function
+        other.is_a?(Column) &&
+          attributes_for_hash == other.attributes_for_hash
       end
       alias :eql? :==
 
@@ -60,16 +52,16 @@ module ActiveRecord
         attributes_for_hash.hash
       end
 
-      private
+      protected
 
       def attributes_for_hash
-        [self.class, name, default, cast_type, sql_type, null, default_function]
+        [self.class, name, default, sql_type_metadata, null, default_function]
       end
     end
 
     class NullColumn < Column
       def initialize(name)
-        super name, nil, Type::Value.new
+        super(name, nil)
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/column.rb b/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
index 8f3628ec0e..0eb4fb468c 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/column.rb
@@ -2,21 +2,9 @@ module ActiveRecord
   module ConnectionAdapters
     # PostgreSQL-specific extensions to column definitions in a table.
     class PostgreSQLColumn < Column #:nodoc:
-      attr_reader :array, :oid, :fmod
+      delegate :array, :oid, :fmod, to: :sql_type_metadata
       alias :array? :array
 
-      def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil, oid = nil, fmod = nil)
-        if sql_type =~ /\[\]$/
-          @array = true
-          sql_type = sql_type[0..sql_type.length - 3]
-        else
-          @array = false
-        end
-        @oid = oid
-        @fmod = fmod
-        super(name, default, cast_type, sql_type, null, default_function)
-      end
-
       def serial?
         default_function && default_function =~ /\Anextval\(.*\)\z/
       end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
index 519a9727fb..d4e183dd16 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
@@ -185,15 +185,15 @@ module ActiveRecord
           column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod|
             oid = oid.to_i
             fmod = fmod.to_i
-            cast_type = get_oid_type(oid, fmod, column_name, type)
-            default_value = extract_value_from_default(cast_type, default)
+            type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
+            default_value = extract_value_from_default(default)
             default_function = extract_default_function(default_value, default)
-            new_column(column_name, default_value, cast_type, type, notnull == 'f', default_function, oid, fmod)
+            new_column(column_name, default_value, type_metadata, notnull == 'f', default_function)
           end
         end
 
-        def new_column(name, default, cast_type, sql_type = nil, null = true, default_function = nil, oid = nil, fmod = nil) # :nodoc:
-          PostgreSQLColumn.new(name, default, cast_type, sql_type, null, default_function, oid, fmod)
+        def new_column(name, default, sql_type_metadata = nil, null = true, default_function = nil) # :nodoc:
+          PostgreSQLColumn.new(name, default, sql_type_metadata, null, default_function)
         end
 
         # Returns the current database name.
@@ -582,6 +582,18 @@ module ActiveRecord
 
           [super, *order_columns].join(', ')
         end
+
+        def fetch_type_metadata(column_name, sql_type, oid, fmod)
+          cast_type = get_oid_type(oid, fmod, column_name, sql_type)
+          simple_type = SqlTypeMetadata.new(
+            sql_type: sql_type,
+            type: cast_type.type,
+            limit: cast_type.limit,
+            precision: cast_type.precision,
+            scale: cast_type.scale,
+          )
+          PostgreSQLTypeMetadata.new(simple_type, oid: oid, fmod: fmod)
+        end
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb b/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb
new file mode 100644
index 0000000000..58715978f7
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/type_metadata.rb
@@ -0,0 +1,35 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLTypeMetadata < DelegateClass(SqlTypeMetadata)
+      attr_reader :oid, :fmod, :array
+
+      def initialize(type_metadata, oid: nil, fmod: nil)
+        super(type_metadata)
+        @type_metadata = type_metadata
+        @oid = oid
+        @fmod = fmod
+        @array = /\[\]$/ === type_metadata.sql_type
+      end
+
+      def sql_type
+        super.gsub(/\[\]$/, "")
+      end
+
+      def ==(other)
+        other.is_a?(PostgreSQLTypeMetadata) &&
+          attributes_for_hash == other.attributes_for_hash
+      end
+      alias eql? ==
+
+      def hash
+        attributes_for_hash.hash
+      end
+
+      protected
+
+      def attributes_for_hash
+        [self.class, @type_metadata, oid, fmod]
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index d789069f0b..ab970e183a 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -1,14 +1,14 @@
-require 'active_record/connection_adapters/abstract_adapter'
-require 'active_record/connection_adapters/statement_pool'
-
-require 'active_record/connection_adapters/postgresql/utils'
-require 'active_record/connection_adapters/postgresql/column'
-require 'active_record/connection_adapters/postgresql/oid'
-require 'active_record/connection_adapters/postgresql/quoting'
-require 'active_record/connection_adapters/postgresql/referential_integrity'
-require 'active_record/connection_adapters/postgresql/schema_definitions'
-require 'active_record/connection_adapters/postgresql/schema_statements'
-require 'active_record/connection_adapters/postgresql/database_statements'
+require "active_record/connection_adapters/abstract_adapter"
+require "active_record/connection_adapters/postgresql/column"
+require "active_record/connection_adapters/postgresql/database_statements"
+require "active_record/connection_adapters/postgresql/oid"
+require "active_record/connection_adapters/postgresql/quoting"
+require "active_record/connection_adapters/postgresql/referential_integrity"
+require "active_record/connection_adapters/postgresql/schema_definitions"
+require "active_record/connection_adapters/postgresql/schema_statements"
+require "active_record/connection_adapters/postgresql/type_metadata"
+require "active_record/connection_adapters/postgresql/utils"
+require "active_record/connection_adapters/statement_pool"
 
 require 'arel/visitors/bind_visitor'
 
@@ -541,7 +541,7 @@ module ActiveRecord
         end
 
         # Extracts the value from a PostgreSQL column default definition.
-        def extract_value_from_default(oid, default) # :nodoc:
+        def extract_value_from_default(default) # :nodoc:
           case default
             # Quoted types
             when /\A[\(B]?'(.*)'::/m
diff --git a/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb b/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb
new file mode 100644
index 0000000000..ccb7e154ee
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/sql_type_metadata.rb
@@ -0,0 +1,32 @@
+module ActiveRecord
+  # :stopdoc:
+  module ConnectionAdapters
+    class SqlTypeMetadata
+      attr_reader :sql_type, :type, :limit, :precision, :scale
+
+      def initialize(sql_type: nil, type: nil, limit: nil, precision: nil, scale: nil)
+        @sql_type = sql_type
+        @type = type
+        @limit = limit
+        @precision = precision
+        @scale = scale
+      end
+
+      def ==(other)
+        other.is_a?(SqlTypeMetadata) &&
+          attributes_for_hash == other.attributes_for_hash
+      end
+      alias eql? ==
+
+      def hash
+        attributes_for_hash.hash
+      end
+
+      protected
+
+      def attributes_for_hash
+        [self.class, sql_type, type, limit, precision, scale]
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index 02a3b65934..c06213a7bf 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -381,8 +381,8 @@ module ActiveRecord
           end
 
           sql_type = field['type']
-          cast_type = lookup_cast_type(sql_type)
-          new_column(field['name'], field['dflt_value'], cast_type, sql_type, field['notnull'].to_i == 0)
+          type_metadata = fetch_type_metadata(sql_type)
+          new_column(field['name'], field['dflt_value'], type_metadata, field['notnull'].to_i == 0)
         end
       end