declare_schema 0.6.4 → 0.8.0.pre.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 523660550181d173c4ff4d6dc181b6d790419a3fdfb1e956076eed2d4c9f7f3b
-  data.tar.gz: '0380d2f800fd64c770c87631090ee792875034211b6ba9d18f5acc34e5ba9f0b'
+  metadata.gz: cd8228bfafad807a853f8abea954459b3ac209b7041b27699fc5691184c86b80
+  data.tar.gz: 01a278f8d7bbc83a9309a3c8908b546c509f5b2d14e28fe11bca2fa4fcc7bbed
 SHA512:
-  metadata.gz: 824d98b6bb3b30d0eebf594db7cead5e954fed227eefdb8f627811da3a7f8c9bc76f62552c3c3a87b0ff3adf51a95a1e666e903d6993430aaa3521607b6ee260
-  data.tar.gz: e8b45fb7dd6df1b314b3ada7e3da6223c631911ce88233165dff486ddb0bfc4a09e42255c018e7d00a456f95d0c1a8af010fe5531f6c2d64516cf3a09f51eb19
+  metadata.gz: 632350f71bb95b99fd7f25f0dd9a71c84d544e1e5d26cafcf3ae671e994c9719be3c7f4f297a096ffdca3ec63c5179aea1c159f600bbb061fa86b99a3d92fc6c
+  data.tar.gz: 757876168af2c046c63332fadc22ce26b63e7697ae5d6c9091b46a4c5d7d349eefc2899052e6e0f2d7df13a200c18f029d881937436e95a17283f1ce709f19f5

data/CHANGELOG.md

@@ -4,11 +4,27 @@ Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.6.4] - 2020-02-08
+## [0.8.0] - UNRELEASED
+### Removed
+- Removed `sql_type` that was confusing because it was actually the same as `type` (ex: :string) and not
+  in fact the SQL type (ex: ``varchar(255)'`).
+
+## [0.7.1] - 2021-02-17
+### Fixed
+- Exclude unknown options from FieldSpec#sql_options and #schema_attributes.
+- Fixed a bug where fk_field_options were getting merged into spec_attrs after checking for equivalence,
+  leading to phantom migrations with no changes, or missing migrations when just the fk_field_options changed.
+
+## [0.7.0] - 2021-02-14
+### Changed
+- Use `schema_attributes` for generating both up and down change migrations, so they are guaranteed to be symmetrical.
+  Note: Rails schema dumper is still used for the down migration to replace a model that has been dropped.
+
+## [0.6.4] - 2021-02-08
 - Fixed a bug where the generated call to add_foreign_key() was not setting `column:`,
   so it only worked in cases where Rails could infer the foreign key by convention.
 
-## [0.6.3] - 2020-01-21
+## [0.6.3] - 2021-01-21
 ### Added
 - Added `add_foreign_key` native rails call in `DeclareSchema::Model::ForeignKeyDefinition#to_add_statement`.
 
@@ -114,6 +130,9 @@ using the appropriate Rails configuration attributes.
 ### Added
 - Initial version from https://github.com/Invoca/hobo_fields v4.1.0.
 
+[0.8.0]: https://github.com/Invoca/declare_schema/compare/v0.7.1...v0.8.0
+[0.7.1]: https://github.com/Invoca/declare_schema/compare/v0.7.0...v0.7.1
+[0.7.0]: https://github.com/Invoca/declare_schema/compare/v0.6.3...v0.7.0
 [0.6.4]: https://github.com/Invoca/declare_schema/compare/v0.6.3...v0.6.4
 [0.6.3]: https://github.com/Invoca/declare_schema/compare/v0.6.2...v0.6.3
 [0.6.2]: https://github.com/Invoca/declare_schema/compare/v0.6.1...v0.6.2

data/Gemfile.lock

@@ -1,49 +1,49 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.6.4)
+    declare_schema (0.8.0.pre.3)
       rails (>= 4.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    actioncable (5.2.4.4)
-      actionpack (= 5.2.4.4)
+    actioncable (5.2.4.5)
+      actionpack (= 5.2.4.5)
       nio4r (~> 2.0)
       websocket-driver (>= 0.6.1)
-    actionmailer (5.2.4.4)
-      actionpack (= 5.2.4.4)
-      actionview (= 5.2.4.4)
-      activejob (= 5.2.4.4)
+    actionmailer (5.2.4.5)
+      actionpack (= 5.2.4.5)
+      actionview (= 5.2.4.5)
+      activejob (= 5.2.4.5)
       mail (~> 2.5, >= 2.5.4)
       rails-dom-testing (~> 2.0)
-    actionpack (5.2.4.4)
-      actionview (= 5.2.4.4)
-      activesupport (= 5.2.4.4)
+    actionpack (5.2.4.5)
+      actionview (= 5.2.4.5)
+      activesupport (= 5.2.4.5)
       rack (~> 2.0, >= 2.0.8)
       rack-test (>= 0.6.3)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (5.2.4.4)
-      activesupport (= 5.2.4.4)
+    actionview (5.2.4.5)
+      activesupport (= 5.2.4.5)
       builder (~> 3.1)
       erubi (~> 1.4)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.0.3)
-    activejob (5.2.4.4)
-      activesupport (= 5.2.4.4)
+    activejob (5.2.4.5)
+      activesupport (= 5.2.4.5)
       globalid (>= 0.3.6)
-    activemodel (5.2.4.4)
-      activesupport (= 5.2.4.4)
-    activerecord (5.2.4.4)
-      activemodel (= 5.2.4.4)
-      activesupport (= 5.2.4.4)
+    activemodel (5.2.4.5)
+      activesupport (= 5.2.4.5)
+    activerecord (5.2.4.5)
+      activemodel (= 5.2.4.5)
+      activesupport (= 5.2.4.5)
       arel (>= 9.0)
-    activestorage (5.2.4.4)
-      actionpack (= 5.2.4.4)
-      activerecord (= 5.2.4.4)
+    activestorage (5.2.4.5)
+      actionpack (= 5.2.4.5)
+      activerecord (= 5.2.4.5)
       marcel (~> 0.3.1)
-    activesupport (5.2.4.4)
+    activesupport (5.2.4.5)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -54,25 +54,25 @@ GEM
       thor (>= 0.14.0)
     arel (9.0.0)
     ast (2.4.1)
-    bootsnap (1.5.1)
+    bootsnap (1.7.2)
       msgpack (~> 1.0)
     builder (3.2.4)
     byebug (11.1.3)
     climate_control (0.2.0)
     coderay (1.1.3)
-    concurrent-ruby (1.1.7)
+    concurrent-ruby (1.1.8)
     crass (1.0.6)
     diff-lcs (1.4.4)
-    erubi (1.9.0)
+    erubi (1.10.0)
     ffi (1.14.2)
     globalid (0.4.2)
       activesupport (>= 4.2.0)
-    i18n (1.8.5)
+    i18n (1.8.9)
       concurrent-ruby (~> 1.0)
     listen (3.4.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
-    loofah (2.7.0)
+    loofah (2.9.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     mail (2.7.1)
@@ -82,12 +82,13 @@ GEM
     method_source (1.0.0)
     mimemagic (0.3.5)
     mini_mime (1.0.2)
-    mini_portile2 (2.4.0)
-    minitest (5.14.2)
-    msgpack (1.3.3)
-    nio4r (2.5.4)
-    nokogiri (1.10.10)
-      mini_portile2 (~> 2.4.0)
+    mini_portile2 (2.5.0)
+    minitest (5.14.3)
+    msgpack (1.4.2)
+    nio4r (2.5.5)
+    nokogiri (1.11.1)
+      mini_portile2 (~> 2.5.0)
+      racc (~> 1.4)
     parallel (1.19.2)
     parser (2.7.1.4)
       ast (~> 2.4.1)
@@ -97,35 +98,36 @@ GEM
     pry-byebug (3.9.0)
       byebug (~> 11.0)
       pry (~> 0.13.0)
+    racc (1.5.2)
     rack (2.2.3)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
-    rails (5.2.4.4)
-      actioncable (= 5.2.4.4)
-      actionmailer (= 5.2.4.4)
-      actionpack (= 5.2.4.4)
-      actionview (= 5.2.4.4)
-      activejob (= 5.2.4.4)
-      activemodel (= 5.2.4.4)
-      activerecord (= 5.2.4.4)
-      activestorage (= 5.2.4.4)
-      activesupport (= 5.2.4.4)
+    rails (5.2.4.5)
+      actioncable (= 5.2.4.5)
+      actionmailer (= 5.2.4.5)
+      actionpack (= 5.2.4.5)
+      actionview (= 5.2.4.5)
+      activejob (= 5.2.4.5)
+      activemodel (= 5.2.4.5)
+      activerecord (= 5.2.4.5)
+      activestorage (= 5.2.4.5)
+      activesupport (= 5.2.4.5)
       bundler (>= 1.3.0)
-      railties (= 5.2.4.4)
+      railties (= 5.2.4.5)
       sprockets-rails (>= 2.0.0)
     rails-dom-testing (2.0.3)
       activesupport (>= 4.2.0)
       nokogiri (>= 1.6)
     rails-html-sanitizer (1.3.0)
       loofah (~> 2.3)
-    railties (5.2.4.4)
-      actionpack (= 5.2.4.4)
-      activesupport (= 5.2.4.4)
+    railties (5.2.4.5)
+      actionpack (= 5.2.4.5)
+      activesupport (= 5.2.4.5)
       method_source
       rake (>= 0.8.7)
       thor (>= 0.19.0, < 2.0)
     rainbow (3.0.0)
-    rake (13.0.1)
+    rake (13.0.3)
     rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
@@ -167,15 +169,15 @@ GEM
       activesupport (>= 4.0)
       sprockets (>= 3.0.0)
     sqlite3 (1.4.2)
-    thor (1.0.1)
+    thor (1.1.0)
     thread_safe (0.3.6)
-    tzinfo (1.2.7)
+    tzinfo (1.2.9)
       thread_safe (~> 0.1)
     unicode-display_width (1.7.0)
     websocket-driver (0.7.3)
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.5)
-    yard (0.9.25)
+    yard (0.9.26)
 
 PLATFORMS
   ruby

data/lib/declare_schema/field_declaration_dsl.rb

@@ -28,13 +28,12 @@ module DeclareSchema
       field(:lock_version, :integer, default: 1, null: false)
     end
 
-    def field(name, type, *args)
-      options = args.extract_options!
-      @model.declare_field(name, type, *(args + [@options.merge(options)]))
+    def field(name, type, *args, **options)
+      @model.declare_field(name, type, *[*args, @options.merge(options)])
     end
 
     def method_missing(name, *args)
-      field(name, args.first, *args[1..-1])
+      field(name, *args)
     end
   end
 end

data/lib/declare_schema/model.rb

@@ -81,8 +81,7 @@ module DeclareSchema
       # arguments. The arguments are forwarded to the #field_added
       # callback, allowing custom metadata to be added to field
       # declarations.
-      def declare_field(name, type, *args)
-        options = args.extract_options!
+      def declare_field(name, type, *args, **options)
         try(:field_added, name, type, args, options)
         add_serialize_for_field(name, type, options)
         add_formatting_for_field(name, type)

data/lib/declare_schema/model/column.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  class UnknownTypeError < RuntimeError; end
+
+  module Model
+    # This class is a wrapper for the ActiveRecord::...::Column class
+    class Column
+      class << self
+        def native_type?(type)
+          type != :primary_key && (native_types.empty? || native_types[type]) # empty will happen with NullDBAdapter used in assets:precompile
+        end
+
+        # MySQL example:
+        # { primary_key: "bigint auto_increment PRIMARY KEY",
+        #   string: { name: "varchar", limit: 255 },
+        #   text: { name: "text", limit: 65535},
+        #   integer: {name: "int", limit: 4 },
+        #   float: {name: "float", limit: 24 },
+        #   decimal: { name: "decimal" },
+        #   datetime: { name: "datetime" },
+        #   timestamp: { name: "timestamp" },
+        #   time: { name: "time" },
+        #   date: { name: "date" },
+        #   binary: { name>: "blob", limit: 65535 },
+        #   boolean: { name: "tinyint", limit: 1 },
+        #   json: { name: "json" } }
+        #
+        # SQLite example:
+        # { primary_key: "integer PRIMARY KEY AUTOINCREMENT NOT NULL",
+        #  string: { name: "varchar" },
+        #  text: { name: "text"},
+        #  integer: { name: "integer" },
+        #  float: { name: "float" },
+        #  decimal: { name: "decimal" },
+        #  datetime: { name: "datetime" },
+        #  time: { name: "time" },
+        #  date: { name: "date" },
+        #  binary: { name: "blob" },
+        #  boolean: { name: "boolean" },
+        #  json: { name: "json" } }
+        def native_types
+          @native_types ||= ActiveRecord::Base.connection.native_database_types.tap do |types|
+            if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
+              types[:text][:limit]    ||= 0xffff
+              types[:binary][:limit]  ||= 0xffff
+            end
+          end
+        end
+
+        def deserialize_default_value(column, type, default_value)
+          type or raise ArgumentError, "must pass type; got #{type.inspect}"
+
+          case Rails::VERSION::MAJOR
+          when 4
+            # TODO: Delete this Rails 4 support ASAP! This could be wrong, since it's using the type of the old column...which
+            # might be getting migrated to a new type. We should be using just type as below. -Colin
+            column.type_cast_from_database(default_value)
+          else
+            cast_type = ActiveRecord::Base.connection.send(:lookup_cast_type, type) or
+              raise "cast_type not found for #{type}"
+            cast_type.deserialize(default_value)
+          end
+        end
+
+        # Normalizes schema attributes for the given database adapter name.
+        # Note that the un-normalized attributes are still useful for generating migrations because those
+        # may be run with a different adapter.
+        # This method never mutates its argument.
+        def normalize_schema_attributes(schema_attributes, db_adapter_name)
+          case schema_attributes[:type]
+          when :boolean
+            schema_attributes.reverse_merge(limit: 1)
+          when :integer
+            schema_attributes.reverse_merge(limit: 8) if db_adapter_name.match?(/sqlite/i)
+          when :float
+            schema_attributes.except(:limit)
+          when :text
+            schema_attributes.except(:limit)          if db_adapter_name.match?(/sqlite/i)
+          when :datetime
+            schema_attributes.reverse_merge(precision: 0)
+          when NilClass
+            raise ArgumentError, ":type key not found; keys: #{schema_attributes.keys.inspect}"
+          end || schema_attributes
+        end
+
+        def equivalent_schema_attributes?(schema_attributes_lhs, schema_attributes_rhs)
+          db_adapter_name = ActiveRecord::Base.connection.class.name
+          normalized_lhs = normalize_schema_attributes(schema_attributes_lhs, db_adapter_name)
+          normalized_rhs = normalize_schema_attributes(schema_attributes_rhs, db_adapter_name)
+
+          normalized_lhs == normalized_rhs
+        end
+      end
+
+      attr_reader :type
+
+      def initialize(model, current_table_name, column)
+        @model = model or raise ArgumentError, "must pass model"
+        @current_table_name = current_table_name or raise ArgumentError, "must pass current_table_name"
+        @column = column or raise ArgumentError, "must pass column"
+        @type = @column.type
+        self.class.native_type?(@type) or raise UnknownTypeError, "#{@type.inspect}"
+      end
+
+      SCHEMA_KEYS = [:type, :limit, :precision, :scale, :null, :default].freeze
+
+      # omits keys with nil values
+      def schema_attributes
+        SCHEMA_KEYS.each_with_object({}) do |key, result|
+          value =
+            case key
+            when :default
+              self.class.deserialize_default_value(@column, @type, @column.default)
+            else
+              col_value = @column.send(key)
+              if col_value.nil? && (native_type = self.class.native_types[@column.type])
+                native_type[key]
+              else
+                col_value
+              end
+            end
+
+          result[key] = value unless value.nil?
+        end.tap do |result|
+          if ActiveRecord::Base.connection.class.name.match?(/mysql/i) && @column.type.in?([:string, :text])
+            result.merge!(collation_and_charset_for_column(@current_table_name, @column.name))
+          end
+        end
+      end
+
+      private
+
+      def collation_and_charset_for_column(current_table_name, column_name)
+        connection    = ActiveRecord::Base.connection
+        connection.class.name.match?(/mysql/i) or raise ArgumentError, "only supported for MySQL"
+
+        database_name = connection.current_database
+
+        defaults = connection.select_one(<<~EOS)
+          SELECT C.character_set_name, C.collation_name
+          FROM information_schema.`COLUMNS` C
+          WHERE C.table_schema = '#{connection.quote_string(database_name)}' AND
+                C.table_name = '#{connection.quote_string(current_table_name)}' AND
+                C.column_name = '#{connection.quote_string(column_name)}';
+        EOS
+
+        defaults && defaults["character_set_name"] or raise "character_set_name missing from #{defaults.inspect} from #{database_name}.#{current_table_name}.#{column_name}"
+        defaults && defaults["collation_name"]     or raise "collation_name missing from #{defaults.inspect}"
+
+        {
+          charset:   defaults["character_set_name"],
+          collation: defaults["collation_name"]
+        }
+      end
+    end
+  end
+end

data/lib/declare_schema/model/field_spec.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'column'
+
 module DeclareSchema
+  class MysqlTextMayNotHaveDefault < RuntimeError; end
+
   module Model
     class FieldSpec
-      class UnknownSqlTypeError < RuntimeError; end
 
       MYSQL_TINYTEXT_LIMIT    = 0xff
       MYSQL_TEXT_LIMIT        = 0xffff
@@ -30,7 +33,18 @@ module DeclareSchema
         end
       end
 
-      attr_reader :model, :name, :type, :position, :options
+      attr_reader :model, :name, :type, :position, :options, :sql_options
+
+      TYPE_SYNONYMS = { timestamp: :datetime }.freeze # TODO: drop this synonym. -Colin
+
+      SQL_OPTIONS     = [:limit, :precision, :scale, :null, :default, :charset, :collation].freeze
+      NON_SQL_OPTIONS = [:ruby_default, :validates].freeze
+      VALID_OPTIONS   = (SQL_OPTIONS + NON_SQL_OPTIONS).freeze
+      OPTION_INDEXES  = Hash[VALID_OPTIONS.each_with_index.to_a].freeze
+
+      VALID_OPTIONS.each do |option|
+        define_method(option) { @options[option] }
+      end
 
       def initialize(model, name, type, position: 0, **options)
         # TODO: TECH-5116
@@ -42,170 +56,71 @@ module DeclareSchema
         @model = model
         @name = name.to_sym
         type.is_a?(Symbol) or raise ArgumentError, "type must be a Symbol; got #{type.inspect}"
-        @type = type
+        @type = TYPE_SYNONYMS[type] || type
         @position = position
-        @options = options
-        case type
+        @options = options.dup
+
+        @options.has_key?(:null) or @options[:null] = false
+
+        case @type
         when :text
-          @options[:default] and raise "default may not be given for :text field #{model}##{@name}"
           if self.class.mysql_text_limits?
+            @options[:default].nil? or raise MysqlTextMayNotHaveDefault, "when using MySQL, non-nil default may not be given for :text field #{model}##{@name}"
             @options[:limit] = self.class.round_up_mysql_text_limit(@options[:limit] || MYSQL_LONGTEXT_LIMIT)
+          else
+            @options.delete(:limit)
           end
         when :string
-          @options[:limit] or raise "limit must be given for :string field #{model}##{@name}: #{@options.inspect}; do you want `limit: 255`?"
+          @options[:limit] or raise "limit: must be given for :string field #{model}##{@name}: #{@options.inspect}; do you want `limit: 255`?"
         when :bigint
           @type = :integer
-          @options = options.merge(limit: 8)
+          @options[:limit] = 8
         end
 
-        if type.in?([:text, :string])
-          if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
-            @options[:charset]   ||= model.table_options[:charset]   || Generators::DeclareSchema::Migration::Migrator.default_charset
-            @options[:collation] ||= model.table_options[:collation] || Generators::DeclareSchema::Migration::Migrator.default_collation
-          end
+        Column.native_type?(@type) or raise UnknownTypeError, "#{@type.inspect} not found in #{Column.native_types.inspect} for adapter #{ActiveRecord::Base.connection.class.name}"
+
+        if @type.in?([:string, :text, :binary, :varbinary, :integer, :enum])
+          @options[:limit] ||= Column.native_types[@type][:limit]
         else
-          @options[:charset]   and raise "charset may only given for :string and :text fields"
-          @options[:collation] and raise "collation may only given for :string and :text fields"
+          @type != :decimal && @options.has_key?(:limit) and warn("unsupported limit: for SQL type #{@type} in field #{model}##{@name}")
+          @options.delete(:limit)
         end
-      end
 
-      TYPE_SYNONYMS = { timestamp: :datetime }.freeze
-
-      SQLITE_COLUMN_CLASS =
-        begin
-          ActiveRecord::ConnectionAdapters::SQLiteColumn
-        rescue NameError
-          NilClass
+        if @type == :decimal
+          @options[:precision] or warn("precision: required for :decimal type in field #{model}##{@name}")
+          @options[:scale] or warn("scale: required for :decimal type in field #{model}##{@name}")
+        else
+          if @type != :datetime
+            @options.has_key?(:precision) and warn("precision: only allowed for :decimal type or :datetime for SQL type #{@type} in field #{model}##{@name}")
+          end
+          @options.has_key?(:scale) and warn("scale: only allowed for :decimal type for SQL type #{@type} in field #{model}##{@name}")
         end
 
-      def sql_type
-        @options[:sql_type] || begin
-                                if native_type?(type)
-                                  type
-                                else
-                                  field_class = DeclareSchema.to_class(type)
-                                  field_class && field_class::COLUMN_TYPE or raise UnknownSqlTypeError, "#{type.inspect} for #{model}##{@name}"
-                                end
-                              end
-      end
-
-      def sql_options
-        @options.except(:ruby_default, :validates)
-      end
-
-      def limit
-        @options[:limit] || native_types[sql_type][:limit]
-      end
-
-      def precision
-        @options[:precision]
-      end
-
-      def scale
-        @options[:scale]
-      end
-
-      def null
-        !:null.in?(@options) || @options[:null]
-      end
-
-      def default
-        @options[:default]
-      end
-
-      def charset
-        @options[:charset]
-      end
-
-      def collation
-        @options[:collation]
-      end
-
-      def same_type?(col_spec)
-        type = sql_type
-        normalized_type           = TYPE_SYNONYMS[type] || type
-        normalized_col_spec_type  = TYPE_SYNONYMS[col_spec.type] || col_spec.type
-        normalized_type == normalized_col_spec_type
-      end
-
-      def different_to?(table_name, col_spec)
-        !same_as(table_name, col_spec)
-      end
-
-      def same_as(table_name, col_spec)
-        same_type?(col_spec) &&
-          same_attributes?(col_spec) &&
-          (!type.in?([:text, :string]) || same_charset_and_collation?(table_name, col_spec))
-      end
-
-      private
-
-      def same_attributes?(col_spec)
-        native_type = native_types[type]
-        check_attributes = [:null, :default]
-        check_attributes += [:precision, :scale] if sql_type == :decimal && !col_spec.is_a?(SQLITE_COLUMN_CLASS)  # remove when rails fixes https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2872
-        check_attributes -= [:default] if sql_type == :text && col_spec.class.name =~ /mysql/i
-        check_attributes << :limit if sql_type.in?([:string, :binary, :varbinary, :integer, :enum]) ||
-                                      (sql_type == :text && self.class.mysql_text_limits?)
-        check_attributes.all? do |k|
-          if k == :default
-            case Rails::VERSION::MAJOR
-            when 4
-              col_spec.type_cast_from_database(col_spec.default) == col_spec.type_cast_from_database(default)
-            else
-              cast_type = ActiveRecord::Base.connection.lookup_cast_type_from_column(col_spec) or raise "cast_type not found for #{col_spec.inspect}"
-              cast_type.deserialize(col_spec.default) == cast_type.deserialize(default)
-            end
+        if @type.in?([:text, :string])
+          if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
+            @options[:charset]   ||= model.table_options[:charset]   || Generators::DeclareSchema::Migration::Migrator.default_charset
+            @options[:collation] ||= model.table_options[:collation] || Generators::DeclareSchema::Migration::Migrator.default_collation
           else
-            col_value = col_spec.send(k)
-            if col_value.nil? && native_type
-              col_value = native_type[k]
-            end
-            col_value == send(k)
+            @options.delete(:charset)
+            @options.delete(:collation)
           end
-        end
-      end
-
-      def same_charset_and_collation?(table_name, col_spec)
-        current_collation_and_charset = collation_and_charset_for_column(table_name, col_spec)
-
-        collation == current_collation_and_charset[:collation] &&
-          charset == current_collation_and_charset[:charset]
-      end
-
-      def collation_and_charset_for_column(table_name, col_spec)
-        column_name   = col_spec.name
-        connection    = ActiveRecord::Base.connection
-
-        if connection.class.name.match?(/mysql/i)
-          database_name = connection.current_database
-
-          defaults = connection.select_one(<<~EOS)
-            SELECT C.character_set_name, C.collation_name
-            FROM information_schema.`COLUMNS` C
-            WHERE C.table_schema = '#{connection.quote_string(database_name)}' AND
-                  C.table_name = '#{connection.quote_string(table_name)}' AND
-                  C.column_name = '#{connection.quote_string(column_name)}';
-          EOS
-
-          defaults["character_set_name"] or raise "character_set_name missing from #{defaults.inspect}"
-          defaults["collation_name"]     or raise "collation_name missing from #{defaults.inspect}"
-
-          {
-            charset:   defaults["character_set_name"],
-            collation: defaults["collation_name"]
-          }
         else
-          {}
+          @options[:charset]   and warn("charset may only given for :string and :text fields for SQL type #{@type} in field #{model}##{@name}")
+          @options[:collation] and warne("collation may only given for :string and :text fields for SQL type #{@type} in field #{model}##{@name}")
         end
-      end
 
-      def native_type?(type)
-        type.to_sym != :primary_key && native_types.has_key?(type)
+        @options = Hash[@options.sort_by { |k, _v| OPTION_INDEXES[k] || 9999 }]
+
+        @sql_options = @options.slice(*SQL_OPTIONS)
       end
 
-      def native_types
-        Generators::DeclareSchema::Migration::Migrator.native_types
+      # returns the attributes for schema migrations as a Hash
+      # omits name and position since those are meta-data above the schema
+      # omits keys with nil values
+      def schema_attributes(col_spec)
+        @sql_options.merge(type: @type).tap do |attrs|
+          attrs[:default] = Column.deserialize_default_value(col_spec, @type, attrs[:default])
+        end.compact
       end
     end
   end