declare_schema 1.3.6 → 1.4.0.colin.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d142143cff509bcd40c65523866ce41b01ff9e5d5eb33914cbe22446f2915d18
-  data.tar.gz: 01c7ab3b0a606c4b21f9b3b4f67cceff09d6b20c699ec291036bd840ca084d86
+  metadata.gz: fe0a594fea50536d529c2d4e42280d9050726e1017524dbaff2b8a77e17c6b41
+  data.tar.gz: 89199ba5b58b936f93a7bfe0409c403b95da8bd771b425b2c61a6afd8a951f2a
 SHA512:
-  metadata.gz: 0264bf26889a2149ae448d8b874f74c32d5fc8a5877a02466e89b62dd5000e7411c4e3dcf2ea6be8534f259a5ae9ebe0bab5f514fc18e4d8629ecd203ebce68a
-  data.tar.gz: b454598ee79b3c3bf6677c3c9e1938931d882755861ad87c546e30f5d2e4d284356bf7fc41936a1e164193786af7ccc9dc2442d61c3af56c37ae339d8166a32b
+  metadata.gz: ff4858ac26953e22a9dbf37ce5b2391295d05ec5a8401361434987e6e90c7fc01543f2bbb1cebaf91a0ce16dadb8ac5c8600d01130c81f361c3728bcd7c23f9b
+  data.tar.gz: 1fabf741327417f5beb76ba694de17e0176db5f63e95922a03d195eb4dcff60d71434cd6aeb4e8ff8212bc0b1fc7cc5a8cb400307efeb87a83593887621d366b

data/CHANGELOG.md

@@ -4,24 +4,11 @@ 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).
 
-## [1.3.6] - 2024-01-22
-### Fixed
-- Add missing commits around connection: and Array check for composite declared primary key.
-
-## [1.3.5] - 2024-01-22
-### Fixed
-- Make `default_charset=` and `default_collation=` lazy so they don't use the database connection to check the
-  MySQL version. Instead, that is checked the first time `default_charset` or `default_collation` is called.
-
-## [1.3.4] - 2024-01-18
-### Fixed
-- Add test for migrating `has_and_belongs_to_many` associations and fix them to properly declare their
-  2 foreign keys as the primary key of the join table, rather than just a unique index.
-
-## [1.3.3] - 2024-01-17
-### Fixed
-- Fix a MySQL 8 bug where MySQL 8+ renames charset 'utf8' to 'utf8mb3' and collation 'utf8_general_ci' to
-  'utf8mb3_unicode_ci'.
+## [1.4] - Unreleased
+### Added
+- Added support for partial indexes with `length:` option.
+### Changed
+- Deprecate index: 'name' and unique: true|false in favor of index: { name: 'name', unique: true|false }.
 
 ## [1.3.2] - 2024-01-12
 ### Fixed

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (1.3.6)
+    declare_schema (1.4.0.colin.1)
       rails (>= 5.0)
 
 GEM

data/README.md

@@ -9,7 +9,7 @@ Make a model and declare your schema within a `declare_schema do ... end` block:
 class Company < ActiveRecord::Base
   declare_schema do
     string  :company_name,  limit: 100
-    string  :ticker_symbol, limit: 4, null: true, index: true, unique: true
+    string  :ticker_symbol, limit: 4, null: true, index: { unique: true }
     integer :employee_count
     text    :comments
 
@@ -60,6 +60,61 @@ declare_schema id: :bigint do
 end
 ```
 
+## declare_schema DSL field (column) declaration
+The `declare_schema` DSL is yielded to the block as shown with block variable `t` (for table).
+Each field (column) is declared with the syntax `t.<type> :<column_name>, <options>` as shown here for the `string` column `company_name`:
+```ruby
+create_table :companies, id: :bigint do |t|
+  t.string   :company_name, null: false, limit: 100
+    ...
+end
+```
+### Field (Column) Types
+All of the ActiveRecord field types are supported, as returned by the database driver in use at the time.
+These typically include:
+- `binary` (blob)
+- `text`
+- `integer`
+- `bigint`
+- `float`
+- `decimal`
+- `date`
+- `time`
+- `datetime`
+- `timestamp`
+- `string` (varchar)
+- `boolean` (tinyint 0 or 1)
+- `json`
+- `array`
+- `enum` (if using the `activerecord-mysql-enum` gem) (MySQL enum)
+
+### Field (Column) Options
+The following field options are:
+- `limit` (integer) - The maximum length of the field. For `text` and `binary` fields, this is the maximum number of bytes.
+ For `string` fields, this is the maximum number of characters, and defaults to `DeclareSchema.default_string_limit`; for `text`, defaults to `DeclareSchema.default_text_limit`.
+ For `enum`
+- `null` (boolean) - Whether the field is nullable. Defaults to `DeclareSchema.default_null`.
+- `default` (any) - The default value for the field.
+- `ruby_default` (Proc) - A callable Ruby Proc that returns the default value for the field. This is useful for default values that require Ruby computation.
+  (Provided by the `attr_default` gem.)
+- `index` (boolean [deprecated] or hash) - Whether to create an index for the field. If `true`, defaults to `{ unique: false }` [deprecated]. See below for supported `index` options.
+- `unique` [deprecated] (boolean) - Whether to create a unique index for the field. Defaults to `false`. Deprecated in favor of `index: { unique: <boolean> }`.
+- `charset` (string) - The character set for the field. Defaults to `default_charset` (see below).
+- `collation` (string) - The collation for the field. Defaults to `default_collation` (see below).
+- `precision` (integer) - The precision for the numeric field.
+- `scale` (integer) - The scale for the numeric field.
+
+### Index Options
+The following `index` options are supported:
+- `name` (string) - The name of the index. Defaults the longest format that will fit within `DeclareSchema.max_index_and_constraint_name_length`. They are tried in this order:
+1. `index_<table>_on_<col1>[_and_<col2>...]>`.
+2. `__<col1>[_<col2>...]>`
+3. `<table_prefix><sha256_of_columns_prefix>`
+- `unique` (boolean) - Whether the index is unique. Defaults to `false`.
+- `order` (synbol or hash) - The index order. If `:asc` or `:desc` is provided, it is used as the order for all columns. If hash is provided, it is used to specify the order of individual columns, where the column names are given as `Symbol` hash keys with values of `:asc` or `:desc` indicating the sort order of that column.
+- `length` (integer or hash) - The partial index length(s). If an integer is provided, it is used as the length for all columns. If a hash is provided, it is used to specify the length for individual columns, where the column names are given as `Symbol` hash keys.
+- `where` (string) - The subset index predicate.
+
 ## Usage without Rails
 
 When using `DeclareSchema` without Rails, you can use the `declare_schema/rake` task to generate the migration file.
@@ -115,13 +170,13 @@ end
 ```
 
 ### clear_default_schema
-This method clears out any previously declared `default_schema`.
+This method clears out any previously declared `default_schema`. This can be useful for tests.
 ```ruby
 DeclareSchema.clear_default_schema
 ```
 
 ### Global Configuration
-Configurations can be set at the global level to customize default declaration for the following values:
+Configurations can be set at globally to customize default declaration for the following values:
 
 #### Text Limit
 The default text limit can be set using the `DeclareSchema.default_text_limit=` method.
@@ -134,8 +189,6 @@ set the default `text limit` value to `0xffff`:
 
 **declare_schema.rb**
 ```ruby
-# frozen_string_literal: true
-
 DeclareSchema.default_text_limit = 0xffff
 ```
 
@@ -150,8 +203,6 @@ set the default `string limit` value to `255`:
 
 **declare_schema.rb**
 ```ruby
-# frozen_string_literal: true
-
 DeclareSchema.default_string_limit = 255
 ```
 
@@ -166,40 +217,34 @@ set the default `null` value to `true`:
 
 **declare_schema.rb**
 ```ruby
-# frozen_string_literal: true
-
 DeclareSchema.default_null = true
 ```
 
 #### Generate Foreign Keys
-The default value for generate foreign keys can be set using the `DeclareSchema.default_generate_foreign_keys=` method.
-This value defaults to `true` and can only be set at the global level.
+You can choose whether to generate foreign keys by using the `DeclareSchema.default_generate_foreign_keys=` method.
+This defaults to `true` and can only be set globally.
 
-For example, adding the following to your `config/initializers` directory will set
-the default `generate foreign keys` value to `false`:
+For example, adding the following to your `config/initializers` directory will cause
+foreign keys not to be generated:
 
 **declare_schema.rb**
 ```ruby
-# frozen_string_literal: true
-
 DeclareSchema.default_generate_foreign_keys = false
 ```
 
 #### Generate Indexing
-The default value for generate indexing can be set using the `DeclareSchema.default_generate_indexing=` method.
-This value defaults to `true` and can only be set at the global level.
+You can choose whether to generate indexes automatically by using the `DeclareSchema.default_generate_indexing=` method.
+This defaults to `true` and can only be set globally.
 
-For example, adding the following to your `config/initializers` directory will
-set the default `generate indexing` value to `false`:
+For example, adding the following to your `config/initializers` directory will cause
+indexes not to be generated by `declare_schema`:
 
 **declare_schema.rb**
 ```ruby
-# frozen_string_literal: true
-
 DeclareSchema.default_generate_indexing = false
 ```
 #### Character Set and Collation
-The character set and collation for all tables and fields can be set at the global level
+The character set and collation for all tables and fields can be set at globally
 using the `Generators::DeclareSchema::Migrator.default_charset=` and
 `Generators::DeclareSchema::Migrator.default_collation=` configuration methods.
 
@@ -208,14 +253,9 @@ turn all tables into `utf8mb4` supporting tables:
 
 **declare_schema.rb**
 ```ruby
-# frozen_string_literal: true
-
 DeclareSchema.default_charset   = "utf8mb4"
 DeclareSchema.default_collation = "utf8mb4_bin"
 ```
-Note: MySQL 8+ aliases charset 'utf8' to 'utf8mb3', and 'utf8_general_ci' to 'utf8mb3_unicode_ci',
-so when running on MySQL 8+, those aliases will be applied by `DeclareSchema`.
-
 #### db:migrate Command
 `declare_schema` can run the migration once it is generated, if the `--migrate` option is passed.
 If not, it will display the command to run later. By default this command is
@@ -224,7 +264,7 @@ bundle exec rails db:migrate
 ```
 If your repo has a different command to run for migrations, you can configure it like this:
 ```ruby
-`DeclareSchema.db_migrate_command = "bundle exec rails db:migrate_immediate"`
+DeclareSchema.db_migrate_command = "bundle exec rails db:migrate_immediate"
 ```
 
 ## The `belongs_to` Association
@@ -233,24 +273,16 @@ association is outside of the `declare_schema do` block, so `declare_schema` int
 infer the foreign key column.
 
 By default, `declare_schema` creates an index for `belongs_to` relations. If this default index is not desired,
-you can use `index: false` in the `belongs_to` expression. This may be the case if for example a different index
-already accounts for it.
+you can use `index: false` in the `belongs_to` expression. This may be the case if, for example, a different index
+already covers those columns at the front.
 
 ## The `has_and_belongs_to_many` Association
 Like the `belongs_to` association, `has_and_belongs_to_many` is outside of the `declare_schema ` block. `declare_schema` similarly
 infers foreign keys (and the intersection table).
 
 ## Ignored Tables
-If a table's schema or metadata are managed elsewhere, `declare_schema` probably should not alter it. Accordingly,
-`declare_schema` can be configured to ignore tables.
-
-`declare_schema` by default ignores these tables:
-- The ActiveRecord `schema_info` table
-- The ActiveRecord schema migrations table (generally named `schema_migrations`)
-- The ActiveRecord internal metadata table (generally named `ar_internal_metadata`)
-- If defined/configured, the CGI ActiveRecordStore session table
-
-Additional tables can be ignored by configuring `Generators::DeclareSchema::Migration::Migrator.ignore_tables`.
+If a table's schema or metadata are managed elsewhere, `declare_schema` can be instructed to ignore it
+by adding those table names to the array assigned to `Generators::DeclareSchema::Migration::Migrator.ignore_tables`.
 For example:
 
 ```ruby
@@ -261,6 +293,12 @@ For example:
 ]
 ```
 
+Note: `declare_schema` always ignores these tables:
+- The ActiveRecord `schema_info` table
+- The ActiveRecord schema migrations table (generally named `schema_migrations`)
+- The ActiveRecord internal metadata table (generally named `ar_internal_metadata`)
+- If defined/configured, the CGI ActiveRecordStore session table
+
 ## Maximum Length of Index and Constraint Names
 
 MySQL limits the length of index and constraint names to 64 characters.
@@ -282,7 +320,10 @@ But later, Unicode was extended beyond U+FFFF to make room for emojis, and with
 UTF-8 require 1-4 bytes (`mb4` or "multi-byte 4"). With this addition, there has
 come a need to dynamically define the character set and collation for individual
 tables and columns in the database. With `declare_schema` this can be configured
-at three separate levels
+at three separate levels.
+
+### Global Configuration
+The global configuration option is explained above in the [Character Set and Collation](#Character-Set-and-Collation) section.
 
 ### Table Configuration
 In order to configure a table's default character set and collation, the `charset` and

data/lib/declare_schema/model/field_spec.rb

@@ -107,9 +107,7 @@ module DeclareSchema
         if @type.in?([:text, :string])
           if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
             @options[:charset]   ||= model._table_options&.[](:charset)   || ::DeclareSchema.default_charset
-            @options[:charset] = DeclareSchema.normalize_charset(@options[:charset])
             @options[:collation] ||= model._table_options&.[](:collation) || ::DeclareSchema.default_collation
-            @options[:collation] = DeclareSchema.normalize_collation(@options[:collation])
           else
             @options.delete(:charset)
             @options.delete(:collation)

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -7,53 +7,46 @@ module DeclareSchema
     class ForeignKeyDefinition
       include Comparable
 
-      attr_reader :foreign_key_column, :constraint_name, :child_table_name, :parent_table_name, :dependent
-
-      # Caller needs to pass either constraint_name or child_table. The child_table is remembered, but it is not part of the key;
-      # it is just used to compute the default constraint_name if no constraint_name is given.
-      def initialize(foreign_key_column, constraint_name: nil, child_table: nil, parent_table: nil, class_name: nil, dependent: nil)
-        @foreign_key_column = foreign_key_column&.to_s or raise ArgumentError "foreign key must not be empty: #{foreign_key_column.inspect}"
-        @constraint_name = constraint_name&.to_s.presence || ::DeclareSchema::Model::IndexDefinition.default_index_name(child_table, [@foreign_key_column])
-        @child_table_name = child_table&.to_s or raise ArgumentError, "child_table must not be nil"
-        @parent_table_name = parent_table&.to_s || infer_parent_table_name_from_class(class_name) || infer_parent_table_name_from_foreign_key_column(@foreign_key_column)
-        dependent.in?([nil, :delete]) or raise ArgumentError, "dependent: must be nil or :delete"
-        @dependent = dependent
+      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :parent_table_name, :child_table_name, :options, :on_delete_cascade
+
+
+      def initialize(model, foreign_key, **options)
+        @model = model
+        @foreign_key = foreign_key.to_s.presence or raise ArgumentError "Foreign key must not be empty: #{foreign_key.inspect}"
+        @options = options
+
+        @child_table_name = model.table_name # unless a table rename, which would happen when a class is renamed??
+        @parent_table_name = options[:parent_table]&.to_s
+        @foreign_key_name = options[:foreign_key]&.to_s || @foreign_key
+
+        @constraint_name = options[:constraint_name]&.to_s.presence ||
+                             model.connection.index_name(model.table_name, column: @foreign_key_name)
+        @on_delete_cascade = options[:dependent] == :delete
       end
 
       class << self
-        def for_table(table_name, connection, dependent: nil)
-          show_create_table = connection.select_rows("show create table #{connection.quote_table_name(table_name)}").first.last
+        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|
-            constraint_name, foreign_key_column, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
-            dependent_value = :delete if dependent || fkc['ON DELETE CASCADE']
-
-            new(foreign_key_column, constraint_name: constraint_name, child_table: table_name, parent_table: parent_table, dependent: dependent_value)
+            name, foreign_key, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
+            options = {
+              constraint_name: name,
+              parent_table:    parent_table,
+              foreign_key:     foreign_key
+            }
+            options[:dependent] = :delete if fkc['ON DELETE CASCADE'] || model.is_a?(DeclareSchema::Model::HabtmModelShim)
+
+            new(model, foreign_key, **options)
           end
         end
       end
 
-      def key
-        @key ||= [@parent_table_name, @foreign_key_column, @dependent].freeze
-      end
-
-      def <=>(rhs)
-        key <=> rhs.key
-      end
-
-      alias eql? ==
-
-      def equivalent?(rhs)
-        self == rhs
-      end
-
-      private
-
       # returns the parent class as a Class object
-      # or nil if no @class_name option given
-      def parent_class(class_name)
-        if class_name
+      # or nil if no :class_name option given
+      def parent_class
+        if (class_name = options[:class_name])
           if class_name.is_a?(Class)
             class_name
           else
@@ -62,12 +55,22 @@ module DeclareSchema
         end
       end
 
-      def infer_parent_table_name_from_class(class_name)
-        parent_class(class_name)&.try(:table_name)
+      def parent_table_name
+        @parent_table_name ||=
+          parent_class&.try(:table_name) ||
+            foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
+      end
+
+      def <=>(rhs)
+        key <=> rhs.send(:key)
       end
 
-      def infer_parent_table_name_from_foreign_key_column(foreign_key_column)
-        foreign_key_column.sub(/_id\z/, '').camelize.constantize.table_name
+      alias eql? ==
+
+      private
+
+      def key
+        @key ||= [@child_table_name, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
       end
 
       def hash

data/lib/declare_schema/model/habtm_model_shim.rb

@@ -4,24 +4,28 @@ module DeclareSchema
   module Model
     class HabtmModelShim
       class << self
-        def from_reflection(reflection)
-          new(reflection.join_table,
-              [reflection.foreign_key, reflection.association_foreign_key],
-              [reflection.active_record.table_name, reflection.klass.table_name],
-              connection: reflection.active_record.connection)
+        def from_reflection(refl)
+          join_table = refl.join_table
+          foreign_keys_and_classes = [
+            [refl.foreign_key.to_s, refl.active_record],
+            [refl.association_foreign_key.to_s, refl.class_name.constantize]
+          ].sort { |a, b| a.first <=> b.first }
+          foreign_keys = foreign_keys_and_classes.map(&:first)
+          foreign_key_classes = foreign_keys_and_classes.map(&:last)
+          # this may fail in weird ways if HABTM is running across two DB connections (assuming that's even supported)
+          # figure that anybody who sets THAT up can deal with their own migrations...
+          connection = refl.active_record.connection
+
+          new(join_table, foreign_keys, foreign_key_classes, connection)
         end
       end
 
-      attr_reader :join_table, :foreign_keys, :parent_table_names, :connection
+      attr_reader :join_table, :foreign_keys, :foreign_key_classes, :connection
 
-      def initialize(join_table, foreign_keys, parent_table_names, connection:)
-        foreign_keys.is_a?(Array) && foreign_keys.size == 2 or
-          raise ArgumentError, "foreign_keys must be <Array[2]>; got #{foreign_keys.inspect}"
-        parent_table_names.is_a?(Array) && parent_table_names.size == 2 or
-          raise ArgumentError, "parent_table_names must be <Array[2]>; got #{parent_table_names.inspect}"
+      def initialize(join_table, foreign_keys, foreign_key_classes, connection)
         @join_table = join_table
-        @foreign_keys = foreign_keys.sort # Rails requires these be in alphabetical order
-        @parent_table_names = @foreign_keys == foreign_keys ? parent_table_names : parent_table_names.reverse # match the above sort
+        @foreign_keys = foreign_keys
+        @foreign_key_classes = foreign_key_classes
         @connection = connection
       end
 
@@ -34,8 +38,8 @@ module DeclareSchema
       end
 
       def field_specs
-        foreign_keys.each_with_index.each_with_object({}) do |(foreign_key, i), result|
-          result[foreign_key] = ::DeclareSchema::Model::FieldSpec.new(self, foreign_key, :bigint, position: i, null: false)
+        foreign_keys.each_with_index.each_with_object({}) do |(v, position), result|
+          result[v] = ::DeclareSchema::Model::FieldSpec.new(self, v, :bigint, position: position, null: false)
         end
       end
 
@@ -44,30 +48,26 @@ module DeclareSchema
       end
 
       def _declared_primary_key
-        foreign_keys
-      end
-
-      def index_definitions
-        [
-          IndexDefinition.new(foreign_keys.last, table_name: table_name, unique: false) # index for queries where we only have the last foreign key
-        ]
+        false # no single-column primary key declared
       end
 
       def index_definitions_with_primary_key
         [
-          *index_definitions,
-          IndexDefinition.new(foreign_keys, name: Model::IndexDefinition::PRIMARY_KEY_NAME, unique: true) # creates a primary composite key on both foreign keys
+          IndexDefinition.new(self, foreign_keys, unique: true, name: Model::IndexDefinition::PRIMARY_KEY_NAME), # creates a primary composite key on both foreign keys
+          IndexDefinition.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
         ]
       end
 
+      alias_method :index_definitions, :index_definitions_with_primary_key
+
       def ignore_indexes
         []
       end
 
       def constraint_specs
         [
-          ForeignKeyDefinition.new(foreign_keys.first, child_table: @join_table, parent_table: parent_table_names.first, constraint_name: "#{join_table}_FK1", dependent: :delete),
-          ForeignKeyDefinition.new(foreign_keys.last, child_table: @join_table, parent_table: parent_table_names.last, constraint_name: "#{join_table}_FK2", dependent: :delete)
+          ForeignKeyDefinition.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
+          ForeignKeyDefinition.new(self, foreign_keys.last, parent_table: foreign_key_classes.last.table_name, constraint_name: "#{join_table}_FK2", dependent: :delete)
         ]
       end
     end

data/lib/declare_schema/model/index_definition.rb

@@ -7,63 +7,65 @@ module DeclareSchema
     class IndexDefinition
       include Comparable
 
-      attr_reader :columns, :explicit_name, :name, :unique, :where
-      alias fields columns # TODO: change callers to use columns. -Colin
+      # TODO: replace `fields` with `columns` and remove alias. -Colin
+      OPTIONS = [:name, :unique, :where, :length].freeze
+      attr_reader :table, :fields, :explicit_name, *OPTIONS
+      alias columns fields
 
       class IndexNameTooLongError < RuntimeError; end
 
       PRIMARY_KEY_NAME = "PRIMARY"
 
-      # Caller needs to pass either name or table_name. The table_name is not remembered; it is just used to compute the
-      # default name if no name is given.
-      def initialize(columns, name: nil, table_name: nil, allow_equivalent: false, unique: false, where: nil)
-        @name = name || self.class.default_index_name(table_name, columns)
-        @columns = Array.wrap(columns).map(&:to_s)
-        @explicit_name = @name unless allow_equivalent
-        unique.in?([false, true]) or raise ArgumentError, "unique must be true or false: got #{unique.inspect}"
-        if @name == PRIMARY_KEY_NAME
-          unique or raise ArgumentError, "primary key index must be unique"
-        end
-        @unique = unique
+      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) || self.class.default_index_name(@table, @fields)
+        @unique = options.delete(:unique) || name == PRIMARY_KEY_NAME || false
+        @length = options.delete(:length)
 
         if DeclareSchema.max_index_and_constraint_name_length && @name.length > DeclareSchema.max_index_and_constraint_name_length
           raise IndexNameTooLongError, "Index '#{@name}' exceeds configured limit of #{DeclareSchema.max_index_and_constraint_name_length} characters. Give it a shorter name, or adjust DeclareSchema.max_index_and_constraint_name_length if you know your database can accept longer names."
         end
 
-        if where
+        if (where = options.delete(:where))
           @where = where.start_with?('(') ? where : "(#{where})"
         end
+
+        options.any? and warn("ignoring unrecognized option(s): #{options.inspect} for model #{model}")
       end
 
       class << self
         # extract IndexSpecs from an existing table
         # includes the PRIMARY KEY index
-        def for_table(table_name, ignore_indexes, connection)
-          primary_key_columns = Array(connection.primary_key(table_name))
-          primary_key_columns.present? or raise "could not find primary key for table #{table_name} in #{connection.columns(table_name).inspect}"
+        def for_model(model, old_table_name = nil)
+          t = old_table_name || model.table_name
 
-          primary_key_found = false
-          index_definitions = connection.indexes(table_name).map do |index|
-            next if ignore_indexes.include?(index.name)
+          primary_key_columns = Array(model.connection.primary_key(t)).presence
+          primary_key_columns or raise "could not find primary key for table #{t} in #{model.connection.columns(t).inspect}"
 
-            if index.name == PRIMARY_KEY_NAME
-              index.columns == primary_key_columns && index.unique or
-                raise "primary key on #{table_name} was not unique on #{primary_key_columns} (was unique=#{index.unique} on #{index.columns})"
+          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
             end
-            new(index.columns, name: index.name, unique: index.unique, where: index.where)
+            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(primary_key_columns, name: PRIMARY_KEY_NAME, unique: true)
+            index_definitions << new(model, primary_key_columns, name: PRIMARY_KEY_NAME, unique: true, where: nil, table_name: old_table_name)
           end
           index_definitions
         end
 
-        def default_index_name(table_name, columns)
+        def default_index_name(table, fields)
           index_name = nil
           [:long_index_name, :short_index_name].find do |method_name|
-            index_name = send(method_name, table_name, columns)
+            index_name = send(method_name, table, fields)
             if DeclareSchema.max_index_and_constraint_name_length.nil? || index_name.length <= DeclareSchema.max_index_and_constraint_name_length
               break index_name
             end
@@ -104,12 +106,21 @@ module DeclareSchema
         name == PRIMARY_KEY_NAME
       end
 
+      def options
+        @options ||=
+          OPTIONS.each_with_object({}) do |option, result|
+            result[option] = send(option)
+          end.freeze
+      end
+
+      # Unique key for this object. Used for equality checking.
       def to_key
-        @to_key ||= [name, *settings].freeze
+        @key ||= [table, fields, options].freeze
       end
 
+      # The index settings for this object. Used for equivalence checking. Does not include the name.
       def settings
-        @settings ||= [columns, unique, where].freeze
+        @settings ||= [table, fields, options.except(:name)].freeze
       end
 
       def hash
@@ -125,7 +136,7 @@ module DeclareSchema
       end
 
       def with_name(new_name)
-        self.class.new(@columns, name: new_name, unique: @unique, allow_equivalent: @explicit_name.nil?, where: @where)
+        self.class.new(@model, @fields, **{ **options, name: new_name })
       end
 
       alias eql? ==

data/lib/declare_schema/model/table_options_definition.rb

@@ -50,17 +50,7 @@ module DeclareSchema
 
       def initialize(table_name, **table_options)
         @table_name    = table_name
-        @table_options = table_options.each_with_object({}) do |(k, v),result|
-          result[k] =
-            case k
-            when :charset
-              DeclareSchema.normalize_charset(v)
-            when :collation
-              DeclareSchema.normalize_collation(v)
-            else
-              v
-            end
-        end
+        @table_options = table_options
       end
 
       def to_key