declare_schema 0.3.0 → 0.5.0.pre.1

data/lib/declare_schema/model/field_spec.rb

@@ -54,6 +54,9 @@ module DeclareSchema
           end
         when :string
           @options[:limit] or raise "limit must be given for :string field #{model}##{@name}: #{@options.inspect}; do you want `limit: 255`?"
+        else
+          @options[:collation] and raise "collation may only given for :string and :text fields"
+          @options[:charset]   and raise "charset may only given for :string and :text fields"
         end
         @position = position_option || model.field_specs.length
       end
@@ -102,6 +105,18 @@ module DeclareSchema
         @options[:default]
       end
 
+      def collation
+        if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
+          (@options[:collation] || model.table_options[:collation] || Generators::DeclareSchema::Migration::Migrator.default_collation).to_s
+        end
+      end
+
+      def charset
+        if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
+          (@options[:charset] || model.table_options[:charset] || Generators::DeclareSchema::Migration::Migrator.default_charset).to_s
+        end
+      end
+
       def same_type?(col_spec)
         type = sql_type
         normalized_type           = TYPE_SYNONYMS[type] || type
@@ -109,36 +124,77 @@ module DeclareSchema
         normalized_type == normalized_col_spec_type
       end
 
-      def different_to?(col_spec)
-        !same_type?(col_spec) ||
-          begin
-            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.any? 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
-              else
-                col_value = col_spec.send(k)
-                if col_value.nil? && native_type
-                  col_value = native_type[k]
-                end
-                col_value != send(k)
-              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
+          else
+            col_value = col_spec.send(k)
+            if col_value.nil? && native_type
+              col_value = native_type[k]
             end
+            col_value == send(k)
           end
+        end
       end
 
-      private
+      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
+          {}
+        end
+      end
 
       def native_type?(type)
         type.to_sym != :primary_key && native_types.has_key?(type)

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class ForeignKeyDefinition
+      include Comparable
+
+      attr_reader :constraint_name, :model, :foreign_key, :options, :on_delete_cascade
+
+      def initialize(model, foreign_key, options = {})
+        @model = model
+        @foreign_key = foreign_key.presence
+        @options = options
+
+        @child_table = model.table_name # unless a table rename, which would happen when a class is renamed??
+        @parent_table_name = options[:parent_table]
+        @foreign_key_name = options[:foreign_key] || self.foreign_key
+        @index_name = options[:index_name] || model.connection.index_name(model.table_name, column: foreign_key)
+        @constraint_name = options[:constraint_name] || @index_name || ''
+        @on_delete_cascade = options[:dependent] == :delete
+
+        # Empty constraint lets mysql generate the name
+      end
+
+      class << self
+        def for_model(model, old_table_name)
+          show_create_table = model.connection.select_rows("show create table #{model.connection.quote_table_name(old_table_name)}").first.last
+          constraints = show_create_table.split("\n").map { |line| line.strip if line['CONSTRAINT'] }.compact
+
+          constraints.map do |fkc|
+            options = {}
+            name, foreign_key, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
+            options[:constraint_name] = name
+            options[:parent_table] = parent_table
+            options[:foreign_key] = foreign_key
+            options[:dependent] = :delete if fkc['ON DELETE CASCADE']
+
+            new(model, foreign_key, options)
+          end
+        end
+      end
+
+      def parent_table_name
+        @parent_table_name ||=
+          if (klass = options[:class_name])
+            klass = klass.to_s.constantize unless klass.is_a?(Class)
+            klass.try(:table_name)
+          end || foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
+      end
+
+      attr_writer :parent_table_name
+
+      def to_add_statement
+        statement = "ALTER TABLE #{@child_table} ADD CONSTRAINT #{@constraint_name} FOREIGN KEY #{@index_name}(#{@foreign_key_name}) REFERENCES #{parent_table_name}(id) #{'ON DELETE CASCADE' if on_delete_cascade}"
+        "execute #{statement.inspect}"
+      end
+
+      def key
+        @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
+      end
+
+      def hash
+        key.hash
+      end
+
+      def <=>(rhs)
+        key <=> rhs.key
+      end
+
+      alias eql? ==
+    end
+  end
+end

data/lib/declare_schema/model/index_definition.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class IndexDefinition
+      include Comparable
+
+      # TODO: replace `fields` with `columns` and remove alias. -Colin
+      attr_reader :table, :fields, :explicit_name, :name, :unique, :where
+      alias columns fields
+
+      class IndexNameTooLongError < RuntimeError; end
+
+      PRIMARY_KEY_NAME = "PRIMARY"
+      MYSQL_INDEX_NAME_MAX_LENGTH = 64
+
+      def initialize(model, fields, options = {})
+        @model = model
+        @table = options.delete(:table_name) || model.table_name
+        @fields = Array.wrap(fields).map(&:to_s)
+        @explicit_name = options[:name] unless options.delete(:allow_equivalent)
+        @name = options.delete(:name) || model.connection.index_name(table, column: @fields).gsub(/index.*_on_/, 'on_')
+        @unique = options.delete(:unique) || name == PRIMARY_KEY_NAME || false
+
+        if @name.length > MYSQL_INDEX_NAME_MAX_LENGTH
+          raise IndexNameTooLongError, "Index '#{@name}' exceeds MySQL limit of #{MYSQL_INDEX_NAME_MAX_LENGTH} characters. Give it a shorter name."
+        end
+
+        if (where = options[:where])
+          @where = where.start_with?('(') ? where : "(#{where})"
+        end
+      end
+
+      class << self
+        # extract IndexSpecs from an existing table
+        # always includes the PRIMARY KEY index
+        def for_model(model, old_table_name = nil)
+          t = old_table_name || model.table_name
+
+          primary_key_columns = Array(model.connection.primary_key(t)).presence || sqlite_compound_primary_key(model, t) or
+            raise "could not find primary key for table #{t} in #{model.connection.columns(t).inspect}"
+
+          primary_key_found = false
+          index_definitions = model.connection.indexes(t).map do |i|
+            model.ignore_indexes.include?(i.name) and next
+            if i.name == PRIMARY_KEY_NAME
+              i.columns == primary_key_columns && i.unique or
+                raise "primary key on #{t} was not unique on #{primary_key_columns} (was unique=#{i.unique} on #{i.columns})"
+              primary_key_found = true
+            elsif i.columns == primary_key_columns && i.unique
+              # skip this primary key index since we'll create it below, with PRIMARY_KEY_NAME
+              next
+            end
+            new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name)
+          end.compact
+
+          if !primary_key_found
+            index_definitions << new(model, primary_key_columns, name: PRIMARY_KEY_NAME, unique: true, where: nil, table_name: old_table_name)
+          end
+          index_definitions
+        end
+
+        private
+
+        # This is the old approach which is still needed for MySQL in Rails 4 and SQLite
+        def sqlite_compound_primary_key(model, table)
+          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) || Rails::VERSION::MAJOR < 5 or return nil
+
+          connection = model.connection.dup
+
+          class << connection   # defeat Rails MySQL driver code that skips the primary key by changing its name to a symbol
+            def each_hash(result)
+              super do |hash|
+                if hash[:Key_name] == PRIMARY_KEY_NAME
+                  hash[:Key_name] = PRIMARY_KEY_NAME.to_sym
+                end
+                yield hash
+              end
+            end
+          end
+
+          pk_index = connection.indexes(table).find { |index| index.name.to_s == PRIMARY_KEY_NAME } or return nil
+
+          Array(pk_index.columns)
+        end
+      end
+
+      def primary_key?
+        name == PRIMARY_KEY_NAME
+      end
+
+      def to_add_statement(new_table_name, existing_primary_key = nil)
+        if primary_key? && !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
+          to_add_primary_key_statement(new_table_name, existing_primary_key)
+        else
+          # Note: + below keeps that interpolated string from being frozen, so we can << into it.
+          r = +"add_index #{new_table_name.to_sym.inspect}, #{fields.map(&:to_sym).inspect}"
+          r << ", unique: true"      if unique
+          r << ", where: '#{where}'" if where.present?
+          r << ", name: '#{name}'"
+          r
+        end
+      end
+
+      def to_add_primary_key_statement(new_table_name, existing_primary_key)
+        drop = "DROP PRIMARY KEY, " if existing_primary_key
+        statement = "ALTER TABLE #{new_table_name} #{drop}ADD PRIMARY KEY (#{fields.join(', ')})"
+        "execute #{statement.inspect}"
+      end
+
+      def to_key
+        @key ||= [table, fields, name, unique, where].map(&:to_s)
+      end
+
+      def settings
+        @settings ||= [table, fields, unique].map(&:to_s)
+      end
+
+      def hash
+        to_key.hash
+      end
+
+      def <=>(rhs)
+        to_key <=> rhs.to_key
+      end
+
+      def equivalent?(rhs)
+        settings == rhs.settings
+      end
+
+      def with_name(new_name)
+        self.class.new(@model, @fields, table_name: @table_name, index_name: @index_name, unique: @unique, name: new_name)
+      end
+
+      alias eql? ==
+    end
+  end
+end

data/lib/declare_schema/model/table_options_definition.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class TableOptionsDefinition
+      include Comparable
+
+      TABLE_OPTIONS_TO_SQL_MAPPINGS = {
+        charset:   'CHARACTER SET',
+        collation: 'COLLATE'
+      }.freeze
+
+      class << self
+        def for_model(model, old_table_name = nil)
+          table_name    = old_table_name || model.table_name
+          table_options = if model.connection.class.name.match?(/mysql/i)
+                            mysql_table_options(model.connection, table_name)
+                          else
+                            {}
+                          end
+
+          new(table_name, table_options)
+        end
+
+        private
+
+        def mysql_table_options(connection, table_name)
+          database = connection.current_database
+          defaults = connection.select_one(<<~EOS)
+            SELECT CCSA.character_set_name, CCSA.collation_name
+            FROM information_schema.`TABLES` T, information_schema.`COLLATION_CHARACTER_SET_APPLICABILITY` CCSA
+            WHERE CCSA.collation_name = T.table_collation AND
+                  T.table_schema = #{connection.quote_string(database)} AND
+                  T.table_name = #{connection.quote_string(table_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"]
+          }
+        end
+      end
+
+      attr_reader :table_name, :table_options
+
+      def initialize(table_name, table_options = {})
+        @table_name    = table_name
+        @table_options = table_options
+      end
+
+      def to_key
+        @key ||= [table_name, table_options].map(&:to_s)
+      end
+
+      def settings
+        @settings ||= table_options.map { |name, value| "#{TABLE_OPTIONS_TO_SQL_MAPPINGS[name]} #{value}" if value }.compact.join(" ")
+      end
+
+      def hash
+        to_key.hash
+      end
+
+      def <=>(rhs)
+        to_key <=> rhs.to_key
+      end
+
+      def equivalent?(rhs)
+        settings == rhs.settings
+      end
+
+      alias eql? ==
+      alias to_s settings
+
+      def alter_table_statement
+        statement = "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name)} #{to_s};"
+        "execute #{statement.inspect}"
+      end
+    end
+  end
+end

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.3.0"
+  VERSION = "0.5.0.pre.1"
 end

data/lib/generators/declare_schema/migration/migrator.rb

@@ -45,14 +45,14 @@ module Generators
           false # no single-column primary key
         end
 
-        def index_specs_with_primary_key
+        def index_definitions_with_primary_key
           [
-            ::DeclareSchema::Model::IndexSpec.new(self, foreign_keys, unique: true, name: "PRIMARY_KEY"),
-            ::DeclareSchema::Model::IndexSpec.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
+            ::DeclareSchema::Model::IndexDefinition.new(self, foreign_keys, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME),
+            ::DeclareSchema::Model::IndexDefinition.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
           ]
         end
 
-        alias_method :index_specs, :index_specs_with_primary_key
+        alias_method :index_definitions, :index_definitions_with_primary_key
 
         def ignore_indexes
           []
@@ -60,8 +60,8 @@ module Generators
 
         def constraint_specs
           [
-            ::DeclareSchema::Model::ForeignKeySpec.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
-            ::DeclareSchema::Model::ForeignKeySpec.new(self, foreign_keys.last,  parent_table: foreign_key_classes.last.table_name,  constraint_name: "#{join_table}_FK2", dependent: :delete)
+            ::DeclareSchema::Model::ForeignKeyDefinition.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
+            ::DeclareSchema::Model::ForeignKeyDefinition.new(self, foreign_keys.last, parent_table: foreign_key_classes.last.table_name, constraint_name: "#{join_table}_FK2", dependent: :delete)
           ]
         end
       end
@@ -69,13 +69,19 @@ module Generators
       class Migrator
         class Error < RuntimeError; end
 
-        @ignore_models                    = []
-        @ignore_tables                    = []
+        DEFAULT_CHARSET   = :utf8mb4
+        DEFAULT_COLLATION = :utf8mb4_general
+
+        @ignore_models                        = []
+        @ignore_tables                        = []
         @before_generating_migration_callback = nil
-        @active_record_class              = ActiveRecord::Base
+        @active_record_class                  = ActiveRecord::Base
+        @default_charset                      = DEFAULT_CHARSET
+        @default_collation                    = DEFAULT_COLLATION
 
         class << self
-          attr_accessor :ignore_models, :ignore_tables, :disable_indexing, :disable_constraints, :active_record_class
+          attr_accessor :ignore_models, :ignore_tables, :disable_indexing, :disable_constraints,
+                        :active_record_class, :default_charset, :default_collation
           attr_reader :before_generating_migration_callback
 
           def active_record_class
@@ -292,56 +298,80 @@ module Generators
             "drop_table :#{t}"
           end * "\n"
 
-          changes = []
-          undo_changes = []
-          index_changes = []
-          undo_index_changes = []
-          fk_changes = []
-          undo_fk_changes = []
+          changes                    = []
+          undo_changes               = []
+          index_changes              = []
+          undo_index_changes         = []
+          fk_changes                 = []
+          undo_fk_changes            = []
+          table_options_changes      = []
+          undo_table_options_changes = []
+
           to_change.each do |t|
             model = models_by_table_name[t]
             table = to_rename.key(t) || model.table_name
             if table.in?(db_tables)
-              change, undo, index_change, undo_index, fk_change, undo_fk = change_table(model, table)
+              change, undo, index_change, undo_index, fk_change, undo_fk, table_options_change, undo_table_options_change = change_table(model, table)
               changes << change
               undo_changes << undo
               index_changes << index_change
               undo_index_changes << undo_index
               fk_changes << fk_change
               undo_fk_changes << undo_fk
+              table_options_changes << table_options_change
+              undo_table_options_changes << undo_table_options_change
             end
           end
 
-          up = [renames, drops, creates, changes, index_changes, fk_changes].flatten.reject(&:blank?) * "\n\n"
-          down = [undo_changes, undo_renames, undo_drops, undo_creates, undo_index_changes, undo_fk_changes].flatten.reject(&:blank?) * "\n\n"
+          up = [renames, drops, creates, changes, index_changes, fk_changes, table_options_changes].flatten.reject(&:blank?) * "\n\n"
+          down = [undo_changes, undo_renames, undo_drops, undo_creates, undo_index_changes, undo_fk_changes, undo_table_options_changes].flatten.reject(&:blank?) * "\n\n"
 
           [up, down]
         end
 
         def create_table(model)
-          longest_field_name = model.field_specs.values.map { |f| f.sql_type.to_s.length }.max
-          disable_auto_increment = model.respond_to?(:disable_auto_increment) && model.disable_auto_increment
-          primary_key_option =
-            if model.primary_key.blank? || disable_auto_increment
-              ", id: false"
-            elsif model.primary_key == "id"
-              ", id: :bigint"
-            else
-              ", primary_key: :#{model.primary_key}"
+          longest_field_name       = model.field_specs.values.map { |f| f.sql_type.to_s.length }.max
+          disable_auto_increment   = model.respond_to?(:disable_auto_increment) && model.disable_auto_increment
+          table_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, table_options_for_model(model))
+          field_definitions        = [
+            disable_auto_increment ? "t.integer :id, limit: 8, auto_increment: false, primary_key: true" : nil,
+            *(model.field_specs.values.sort_by(&:position).map { |f| create_field(f, longest_field_name) })
+          ].compact
+
+          <<~EOS.strip
+            create_table :#{model.table_name}, #{create_table_options(model, disable_auto_increment)} do |t|
+              #{field_definitions.join("\n")}
             end
-          (["create_table :#{model.table_name}#{primary_key_option} do |t|"] +
-          [(disable_auto_increment ? "  t.integer :id, limit: 8, auto_increment: false, primary_key: true" : nil)] +
-           model.field_specs.values.sort_by(&:position).map { |f| create_field(f, longest_field_name) } +
-           ["end"] + (if Migrator.disable_indexing
-                        []
-                      else
-                        create_indexes(model) +
-                           create_constraints(model)
-                      end)).compact * "\n"
+
+            #{table_options_definition.alter_table_statement unless ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)}
+            #{create_indexes(model).join("\n")               unless Migrator.disable_indexing}
+            #{create_constraints(model).join("\n")           unless Migrator.disable_indexing}
+          EOS
+        end
+
+        def create_table_options(model, disable_auto_increment)
+          if model.primary_key.blank? || disable_auto_increment
+            "id: false"
+          elsif model.primary_key == "id"
+            "id: :bigint"
+          else
+            "primary_key: :#{model.primary_key}"
+          end
+        end
+
+        def table_options_for_model(model)
+          if ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
+            {}
+          else
+            {
+              charset:   model.table_options[:charset] || Migrator.default_charset,
+              collation: model.table_options[:collation] || Migrator.default_collation
+            }
+          end
         end
 
         def create_indexes(model)
-          model.index_specs.map { |i| i.to_add_statement(model.table_name) }
+          model.index_definitions.map { |i| i.to_add_statement(model.table_name) }
         end
 
         def create_constraints(model)
@@ -351,7 +381,7 @@ module Generators
         def create_field(field_spec, field_name_width)
           options = fk_field_options(field_spec.model, field_spec.name).merge(field_spec.sql_options)
           args = [field_spec.name.inspect] + format_options(options, field_spec.sql_type)
-          format("  t.%-*s %s", field_name_width, field_spec.sql_type, args.join(', '))
+          format("t.%-*s %s", field_name_width, field_spec.sql_type, args.join(', '))
         end
 
         def change_table(model, current_table_name)
@@ -413,15 +443,17 @@ module Generators
             col_name = old_names[c] || c
             col = db_columns[col_name]
             spec = model.field_specs[c]
-            if spec.different_to?(col) # TODO: DRY this up to a diff function that returns the differences. It's different if it has differences. -Colin
+            if spec.different_to?(current_table_name, col) # TODO: TECH-4814 DRY this up to a diff function that returns the differences. It's different if it has differences. -Colin
               change_spec = fk_field_options(model, c)
               change_spec[:limit]     ||= spec.limit   if (spec.sql_type != :text ||
                                                          ::DeclareSchema::Model::FieldSpec.mysql_text_limits?) &&
                                                           (spec.limit || col.limit)
-              change_spec[:precision] = spec.precision unless spec.precision.nil?
-              change_spec[:scale]     = spec.scale     unless spec.scale.nil?
-              change_spec[:null]      = spec.null      unless spec.null && col.null
-              change_spec[:default]   = spec.default   unless spec.default.nil? && col.default.nil?
+              change_spec[:precision]     = spec.precision     unless spec.precision.nil?
+              change_spec[:scale]         = spec.scale         unless spec.scale.nil?
+              change_spec[:null]          = spec.null          unless spec.null && col.null
+              change_spec[:default]       = spec.default       unless spec.default.nil? && col.default.nil?
+              change_spec[:collation]     = spec.collation     unless spec.collation.nil?
+              change_spec[:charset]       = spec.charset       unless spec.charset.nil?
 
               changes << "change_column :#{new_table_name}, :#{c}, " +
                          ([":#{spec.sql_type}"] + format_options(change_spec, spec.sql_type, changing: true)).join(", ")
@@ -436,21 +468,28 @@ module Generators
                                         else
                                           change_foreign_key_constraints(model, current_table_name)
                                         end
+          table_options_changes, undo_table_options_changes = if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
+                                                                change_table_options(model, current_table_name)
+                                                              else
+                                                                [[], []]
+                                                              end
 
           [(renames + adds + removes + changes) * "\n",
            (undo_renames + undo_adds + undo_removes + undo_changes) * "\n",
            index_changes * "\n",
            undo_index_changes * "\n",
            fk_changes * "\n",
-           undo_fk_changes * "\n"]
+           undo_fk_changes * "\n",
+           table_options_changes * "\n",
+           undo_table_options_changes * "\n"]
         end
 
         def change_indexes(model, old_table_name)
           return [[], []] if Migrator.disable_constraints
 
           new_table_name = model.table_name
-          existing_indexes = ::DeclareSchema::Model::IndexSpec.for_model(model, old_table_name)
-          model_indexes_with_equivalents = model.index_specs_with_primary_key
+          existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_model(model, old_table_name)
+          model_indexes_with_equivalents = model.index_definitions_with_primary_key
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
               if ex = existing_indexes.find { |e| i != e && e.equivalent?(i) }
@@ -458,20 +497,20 @@ module Generators
               end
             end || i
           end
-          existing_has_primary_key = existing_indexes.any? { |i| i.name == 'PRIMARY_KEY' }
-          model_has_primary_key    = model_indexes.any?    { |i| i.name == 'PRIMARY_KEY' }
+          existing_has_primary_key = existing_indexes.any? { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
+          model_has_primary_key    = model_indexes.any?    { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
 
           add_indexes_init = model_indexes - existing_indexes
           drop_indexes_init = existing_indexes - model_indexes
           undo_add_indexes = []
           undo_drop_indexes = []
           add_indexes = add_indexes_init.map do |i|
-            undo_add_indexes << drop_index(old_table_name, i.name) unless i.name == "PRIMARY_KEY"
+            undo_add_indexes << drop_index(old_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
             i.to_add_statement(new_table_name, existing_has_primary_key)
           end
           drop_indexes = drop_indexes_init.map do |i|
             undo_drop_indexes << i.to_add_statement(old_table_name, model_has_primary_key)
-            drop_index(new_table_name, i.name) unless i.name == "PRIMARY_KEY"
+            drop_index(new_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
           end.compact
 
           # the order is important here - adding a :unique, for instance needs to remove then add
@@ -489,7 +528,7 @@ module Generators
           return [[], []] if Migrator.disable_indexing
 
           new_table_name = model.table_name
-          existing_fks = ::DeclareSchema::Model::ForeignKeySpec.for_model(model, old_table_name)
+          existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_model(model, old_table_name)
           model_fks = model.constraint_specs
           add_fks = model_fks - existing_fks
           drop_fks = existing_fks - model_fks
@@ -552,6 +591,20 @@ module Generators
           end
         end
 
+        def change_table_options(model, current_table_name)
+          old_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.for_model(model, current_table_name)
+          new_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, table_options_for_model(model))
+
+          if old_options_definition.equivalent?(new_options_definition)
+            [[], []]
+          else
+            [
+              [new_options_definition.alter_table_statement],
+              [old_options_definition.alter_table_statement]
+            ]
+          end
+        end
+
         def revert_table(table)
           res = StringIO.new
           schema_dumper_klass = case Rails::VERSION::MAJOR