strong_migrations 1.2.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c0ea5c8cf3e904b89b8c4ab2f28ff60031515e40edf5b0c617ca4b8f8249650
-  data.tar.gz: 5cb0fd63058bf618595cd929ef90de3cf90f02963f0adca21182c578f41c3320
+  metadata.gz: 23737504a1d3beb08bf2412b161b8e59a8a620b4f4d993f11fe931e7f1772452
+  data.tar.gz: 993dc5f9d78cba148540a22772c18ed115ea6ae8075dd209cc3a869cc2a647a4
 SHA512:
-  metadata.gz: 50db9d240d49b60b75d97c76765b8f5e3b252c2cc826bd5e50e9b57311082dfea2c9cc5790fd905a2eac45a3eb6afb2784c7ed7962dcaf0172157548e1c8d233
-  data.tar.gz: 2f2e5311cad061b712ee9dfb69a41b5e81f31be8db257bd095cbd8124bc461551afebb305d95b0bb090d6f7ef85c61618d61e64e9b73f266338a0aa7f5101b53
+  metadata.gz: e906dc1c79d12a72a7d0e6fb4ca87319095d3b0a39f2da1dbd08b453d19e3215892745c86f80bf9ea26bbf07173d87022aab21b424a881f24744b65396fcd9bc
+  data.tar.gz: 56a0dadcb236f09a1a7d5450456ae343ac8cb6662b65f983c28b4268edad6e7cbecfa47c86ebb0d1da72dcc1b305e7196521811a48838c25beb1119846a2b928

data/CHANGELOG.md

@@ -1,3 +1,47 @@
+## 1.6.0 (2023-07-22)
+
+- Added check for `change_column_default`
+
+## 1.5.0 (2023-07-02)
+
+- Added check for `add_column` with stored generated columns
+- Fixed `add_reference` with `foreign_key` and `index: false`
+
+## 1.4.4 (2023-03-08)
+
+- Fixed `add_foreign_key` with `name` and `column` options with `safe_by_default`
+
+## 1.4.3 (2023-02-19)
+
+- Fixed check for `change_column` to account for charset with MySQL and MariaDB
+
+## 1.4.2 (2023-01-29)
+
+- Added `alphabetize_schema` option
+
+## 1.4.1 (2023-01-05)
+
+- Added support for multiple databases to `target_version`
+
+## 1.4.0 (2022-10-31)
+
+- Added check for `add_exclusion_constraint`
+- Added support for `RACK_ENV`
+- Fixed error when `Rails` defined without `Rails.env`
+- Fixed error with `change_column_null` when table does not exist
+
+## 1.3.2 (2022-10-09)
+
+- Improved error message for `add_column` with `default: nil` with Postgres 10
+
+## 1.3.1 (2022-09-21)
+
+- Fixed check for `add_column` with `default: nil` with Postgres 10
+
+## 1.3.0 (2022-08-30)
+
+- Added check for `add_column` with `uuid` type and volatile default value
+
 ## 1.2.0 (2022-06-10)
 
 - Added check for index corruption with Postgres 14.0 to 14.3

data/README.md

@@ -62,6 +62,7 @@ Potentially dangerous operations:
 - [removing a column](#removing-a-column)
 - [adding a column with a default value](#adding-a-column-with-a-default-value)
 - [backfilling data](#backfilling-data)
+- [adding a stored generated column](#adding-a-stored-generated-column)
 - [changing the type of a column](#changing-the-type-of-a-column)
 - [renaming a column](#renaming-a-column)
 - [renaming a table](#renaming-a-table)
@@ -74,9 +75,14 @@ Postgres-specific checks:
 - [adding an index non-concurrently](#adding-an-index-non-concurrently)
 - [adding a reference](#adding-a-reference)
 - [adding a foreign key](#adding-a-foreign-key)
+- [adding an exclusion constraint](#adding-an-exclusion-constraint)
 - [adding a json column](#adding-a-json-column)
 - [setting NOT NULL on an existing column](#setting-not-null-on-an-existing-column)
 
+Config-specific checks:
+
+- [changing the default value of a column](#changing-the-default-value-of-a-column)
+
 Best practices:
 
 - [keeping non-unique indexes to three columns or less](#keeping-non-unique-indexes-to-three-columns-or-less)
@@ -107,7 +113,7 @@ end
   end
   ```
 
-2. Deploy code
+2. Deploy the code
 3. Write a migration to remove the column (wrap in `safety_assured` block)
 
   ```ruby
@@ -118,7 +124,7 @@ end
   end
   ```
 
-4. Deploy and run migration
+4. Deploy and run the migration
 5. Remove the line added in step 1
 
 ### Adding a column with a default value
@@ -135,7 +141,7 @@ class AddSomeColumnToUsers < ActiveRecord::Migration[7.0]
 end
 ```
 
-In Postgres 11+, MySQL 8.0.12+, and MariaDB 10.3.2+, this no longer requires a table rewrite and is safe.
+In Postgres 11+, MySQL 8.0.12+, and MariaDB 10.3.2+, this no longer requires a table rewrite and is safe (except for volatile functions like `gen_random_uuid()`).
 
 #### Good
 
@@ -190,6 +196,24 @@ class BackfillSomeColumn < ActiveRecord::Migration[7.0]
 end
 ```
 
+### Adding a stored generated column
+
+#### Bad
+
+Adding a stored generated column causes the entire table to be rewritten. During this time, reads and writes are blocked in Postgres, and writes are blocked in MySQL and MariaDB.
+
+```ruby
+class AddSomeColumnToUsers < ActiveRecord::Migration[7.0]
+  def change
+    add_column :users, :some_column, :virtual, type: :string, as: "...", stored: true
+  end
+end
+```
+
+#### Good
+
+Add a non-generated column and use callbacks or triggers instead (or a virtual generated column with MySQL and MariaDB).
+
 ### Changing the type of a column
 
 #### Bad
@@ -223,7 +247,7 @@ And some in MySQL and MariaDB:
 
 Type | Safe Changes
 --- | ---
-`string` | Increasing `:limit` from under 255 up to 255, increasing `:limit` from over 255 to the max
+`string` | Increasing `:limit` from under 63 up to 63, increasing `:limit` from over 63 to the max (the threshold can be different if using an encoding other than `utf8mb4` - for instance, it’s 85 for `utf8mb3` and 255 for `latin1`)
 
 #### Good
 
@@ -488,6 +512,24 @@ class ValidateForeignKeyOnUsers < ActiveRecord::Migration[7.0]
 end
 ```
 
+### Adding an exclusion constraint
+
+#### Bad
+
+In Postgres, adding an exclusion constraint blocks reads and writes while every row is checked.
+
+```ruby
+class AddExclusionContraint < ActiveRecord::Migration[7.1]
+  def change
+    add_exclusion_constraint :users, "number WITH =", using: :gist
+  end
+end
+```
+
+#### Good
+
+[Let us know](https://github.com/ankane/strong_migrations/issues/new) if you have a safe way to do this (exclusion constraints cannot be marked `NOT VALID`).
+
 ### Adding a json column
 
 #### Bad
@@ -590,6 +632,36 @@ class ValidateSomeColumnNotNull < ActiveRecord::Migration[6.0]
 end
 ```
 
+### Changing the default value of a column
+
+#### Bad
+
+Rails < 7 enables partial writes by default, which can cause incorrect values to be inserted when changing the default value of a column.
+
+```ruby
+class ChangeSomeColumnDefault < ActiveRecord::Migration[6.1]
+  def change
+    change_column_default :users, :some_column, from: "old", to: "new"
+  end
+end
+
+User.create!(some_column: "old") # can insert "new"
+```
+
+#### Good
+
+Disable partial writes in `config/application.rb`. For Rails < 7, use:
+
+```ruby
+config.active_record.partial_writes = false
+```
+
+For Rails 7, use:
+
+```ruby
+config.active_record.partial_inserts = false
+```
+
 ### Keeping non-unique indexes to three columns or less
 
 #### Bad
@@ -681,7 +753,7 @@ Disable specific checks with:
 StrongMigrations.disable_check(:add_index)
 ```
 
-Check the [source code](https://github.com/ankane/strong_migrations/blob/master/lib/strong_migrations.rb) for the list of keys.
+Check the [source code](https://github.com/ankane/strong_migrations/blob/master/lib/strong_migrations/error_messages.rb) for the list of keys.
 
 ## Down Migrations / Rollbacks
 
@@ -805,6 +877,12 @@ The major version works well for Postgres, while the full version is recommended
 
 For safety, this option only affects development and test environments. In other environments, the actual server version is always used.
 
+If your app has multiple databases with different versions, with Rails 6.1+, you can use:
+
+```ruby
+StrongMigrations.target_version = {primary: 13, catalog: 15}
+```
+
 ## Analyze Tables
 
 Analyze tables automatically (to update planner statistics) after an index is added. Create an initializer with:
@@ -815,23 +893,18 @@ StrongMigrations.auto_analyze = true
 
 ## Faster Migrations
 
-Only dump the schema when adding a new migration. If you use Git, add to the end of your `Rakefile`:
+Only dump the schema when adding a new migration. If you use Git, add to `config/environments/development.rb`:
 
 ```rb
-task :faster_migrations do
-  ActiveRecord::Base.dump_schema_after_migration = Rails.env.development? &&
-    `git status db/migrate/ --porcelain`.present?
-end
-
-task "db:migrate": "faster_migrations"
+config.active_record.dump_schema_after_migration = `git status db/migrate/ --porcelain`.present?
 ```
 
 ## Schema Sanity
 
-Columns can flip order in `db/schema.rb` when you have multiple developers. One way to prevent this is to [alphabetize them](https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/). Add to the end of your `Rakefile`:
+Columns can flip order in `db/schema.rb` when you have multiple developers. One way to prevent this is to [alphabetize them](https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/). Add to `config/initializers/strong_migrations.rb`:
 
 ```ruby
-task "db:schema:dump": "strong_migrations:alphabetize_columns"
+StrongMigrations.alphabetize_schema = true
 ```
 
 ## Permissions

data/lib/strong_migrations/adapters/abstract_adapter.rb

@@ -50,7 +50,23 @@ module StrongMigrations
         target_version ||= StrongMigrations.target_version
         version =
           if target_version && StrongMigrations.developer_env?
-            target_version.to_s
+            if target_version.is_a?(Hash)
+              # Active Record 6.0 supports multiple databases
+              # but connection.pool.spec.name always returns "primary"
+              # in migrations with rails db:migrate
+              if ActiveRecord::VERSION::STRING.to_f < 6.1
+                # error class is not shown in db:migrate output so ensure message is descriptive
+                raise StrongMigrations::Error, "StrongMigrations.target_version does not support multiple databases for Active Record < 6.1"
+              end
+
+              db_config_name = connection.pool.db_config.name
+              target_version.stringify_keys.fetch(db_config_name) do
+                # error class is not shown in db:migrate output so ensure message is descriptive
+                raise StrongMigrations::Error, "StrongMigrations.target_version is not configured for :#{db_config_name} database"
+              end.to_s
+            else
+              target_version.to_s
+            end
           else
             yield
           end

data/lib/strong_migrations/adapters/mariadb_adapter.rb

@@ -18,6 +18,9 @@ module StrongMigrations
       end
 
       def set_statement_timeout(timeout)
+        # fix deprecation warning with Active Record 7.1
+        timeout = timeout.value if timeout.is_a?(ActiveSupport::Duration)
+
         select_all("SET max_statement_time = #{connection.quote(timeout)}")
       end
 

data/lib/strong_migrations/adapters/mysql_adapter.rb

@@ -25,6 +25,9 @@ module StrongMigrations
       end
 
       def set_lock_timeout(timeout)
+        # fix deprecation warning with Active Record 7.1
+        timeout = timeout.value if timeout.is_a?(ActiveSupport::Duration)
+
         select_all("SET lock_wait_timeout = #{connection.quote(timeout)}")
       end
 
@@ -49,14 +52,31 @@ module StrongMigrations
 
         case type.to_s
         when "string"
-          # https://dev.mysql.com/doc/refman/5.7/en/innodb-online-ddl-operations.html
-          # https://mariadb.com/kb/en/innodb-online-ddl-operations-with-the-instant-alter-algorithm/#changing-the-data-type-of-a-column
-          # increased limit, but doesn't change number of length bytes
-          # 1-255 = 1 byte, 256-65532 = 2 bytes, 65533+ = too big for varchar
           limit = options[:limit] || 255
-          safe = ["varchar"].include?(existing_type) &&
-            limit >= existing_column.limit &&
-            (limit <= 255 || existing_column.limit > 255)
+          if ["varchar"].include?(existing_type) && limit >= existing_column.limit
+            # https://dev.mysql.com/doc/refman/5.7/en/innodb-online-ddl-operations.html
+            # https://mariadb.com/kb/en/innodb-online-ddl-operations-with-the-instant-alter-algorithm/#changing-the-data-type-of-a-column
+            # increased limit, but doesn't change number of length bytes
+            # 1-255 = 1 byte, 256-65532 = 2 bytes, 65533+ = too big for varchar
+
+            # account for charset
+            # https://dev.mysql.com/doc/refman/8.0/en/charset-mysql.html
+            # https://mariadb.com/kb/en/supported-character-sets-and-collations/
+            sql = <<~SQL
+              SELECT cs.MAXLEN
+              FROM INFORMATION_SCHEMA.CHARACTER_SETS cs
+              INNER JOIN INFORMATION_SCHEMA.COLLATIONS c ON c.CHARACTER_SET_NAME = cs.CHARACTER_SET_NAME
+              INNER JOIN INFORMATION_SCHEMA.TABLES t ON t.TABLE_COLLATION = c.COLLATION_NAME
+              WHERE t.TABLE_SCHEMA = database() AND t.TABLE_NAME = #{connection.quote(table)}
+            SQL
+            row = connection.select_all(sql).first
+            if row
+              threshold = 255 / row["MAXLEN"]
+              safe = limit <= threshold || existing_column.limit > threshold
+            else
+              warn "[strong_migrations] Could not determine charset"
+            end
+          end
         end
 
         safe

data/lib/strong_migrations/adapters/postgresql_adapter.rb

@@ -14,11 +14,7 @@ module StrongMigrations
           target_version(StrongMigrations.target_postgresql_version) do
             version = select_all("SHOW server_version_num").first["server_version_num"].to_i
             # major and minor version
-            if version >= 100000
-              "#{version / 10000}.#{(version % 10000)}"
-            else
-              "#{version / 10000}.#{(version % 10000) / 100}"
-            end
+            "#{version / 10000}.#{(version % 10000)}"
           end
         end
       end
@@ -76,7 +72,7 @@ module StrongMigrations
           # but there doesn't seem to be a way to set/modify it
           # https://wiki.postgresql.org/wiki/What%27s_new_in_PostgreSQL_9.2#Reduce_ALTER_TABLE_rewrites
         when "numeric", "decimal"
-          # numeric and decimal are equivalent and can be used interchangably
+          # numeric and decimal are equivalent and can be used interchangeably
           safe = ["numeric", "decimal"].include?(existing_type) &&
             (
               (
@@ -166,6 +162,13 @@ module StrongMigrations
           !StrongMigrations.developer_env?
       end
 
+      # default to true if unsure
+      def default_volatile?(default)
+        name = default.to_s.delete_suffix("()")
+        rows = select_all("SELECT provolatile FROM pg_proc WHERE proname = #{connection.quote(name)}").to_a
+        rows.empty? || rows.any? { |r| r["provolatile"] == "v" }
+      end
+
       private
 
       def set_timeout(setting, timeout)

data/lib/strong_migrations/checker.rb

@@ -8,6 +8,7 @@ module StrongMigrations
     def initialize(migration)
       @migration = migration
       @new_tables = []
+      @new_columns = []
       @safe = false
       @timeouts_set = false
       @committed = false
@@ -36,6 +37,8 @@ module StrongMigrations
           check_add_check_constraint(*args)
         when :add_column
           check_add_column(*args)
+        when :add_exclusion_constraint
+          check_add_exclusion_constraint(*args)
         when :add_foreign_key
           check_add_foreign_key(*args)
         when :add_index
@@ -44,6 +47,8 @@ module StrongMigrations
           check_add_reference(method, *args)
         when :change_column
           check_change_column(*args)
+        when :change_column_default
+          check_change_column_default(*args)
         when :change_column_null
           check_change_column_null(*args)
         when :change_table

data/lib/strong_migrations/checks.rb

@@ -32,7 +32,14 @@ module StrongMigrations
       table, column, type = args
       default = options[:default]
 
-      if !default.nil? && !adapter.add_column_default_safe?
+      # keep track of new columns of change_column_default check
+      @new_columns << [table.to_s, column.to_s]
+
+      # Check key since DEFAULT NULL behaves differently from no default
+      #
+      # Also, Active Record has special case for uuid columns that allows function default values
+      # https://github.com/rails/rails/blob/v7.0.3.1/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb#L92-L93
+      if options.key?(:default) && (!adapter.add_column_default_safe? || (volatile = (postgresql? && type.to_s == "uuid" && default.to_s.include?("()") && adapter.default_volatile?(default))))
         if options[:null] == false
           options = options.except(:null)
           append = "
@@ -40,13 +47,21 @@ module StrongMigrations
 Then add the NOT NULL constraint in separate migrations."
         end
 
-        raise_error :add_column_default,
-          add_command: command_str("add_column", [table, column, type, options.except(:default)]),
-          change_command: command_str("change_column_default", [table, column, default]),
-          remove_command: command_str("remove_column", [table, column]),
-          code: backfill_code(table, column, default),
-          append: append,
-          rewrite_blocks: adapter.rewrite_blocks
+        if default.nil?
+          raise_error :add_column_default_null,
+            command: command_str("add_column", [table, column, type, options.except(:default)]),
+            append: append,
+            rewrite_blocks: adapter.rewrite_blocks
+        else
+          raise_error :add_column_default,
+            add_command: command_str("add_column", [table, column, type, options.except(:default)]),
+            change_command: command_str("change_column_default", [table, column, default]),
+            remove_command: command_str("remove_column", [table, column]),
+            code: backfill_code(table, column, default, volatile),
+            append: append,
+            rewrite_blocks: adapter.rewrite_blocks,
+            default_type: (volatile ? "volatile" : "non-null")
+        end
       elsif default.is_a?(Proc) && postgresql?
         # adding a column with a VOLATILE default is not safe
         # https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-NOTES
@@ -59,6 +74,18 @@ Then add the NOT NULL constraint in separate migrations."
         raise_error :add_column_json,
           command: command_str("add_column", [table, column, :jsonb, options])
       end
+
+      if type.to_s == "virtual" && options[:stored]
+        raise_error :add_column_generated_stored, rewrite_blocks: adapter.rewrite_blocks
+      end
+    end
+
+    def check_add_exclusion_constraint(*args)
+      table = args[0]
+
+      unless new_table?(table)
+        raise_error :add_exclusion_constraint
+      end
     end
 
     # unlike add_index, we don't make an exception here for new tables
@@ -127,7 +154,7 @@ Then add the NOT NULL constraint in separate migrations."
         if bad_index || options[:foreign_key]
           if index_value.is_a?(Hash)
             options[:index] = options[:index].merge(algorithm: :concurrently)
-          else
+          elsif index_value
             options = options.merge(index: {algorithm: :concurrently})
           end
 
@@ -158,7 +185,8 @@ Then add the foreign key in separate migrations."
       table, column, type = args
 
       safe = false
-      existing_column = connection.columns(table).find { |c| c.name.to_s == column.to_s }
+      table_columns = connection.columns(table) rescue []
+      existing_column = table_columns.find { |c| c.name.to_s == column.to_s }
       if existing_column
         existing_type = existing_column.sql_type.sub(/\(\d+(,\d+)?\)/, "")
         safe = adapter.change_type_safe?(table, column, type, options, existing_column, existing_type)
@@ -173,6 +201,18 @@ Then add the foreign key in separate migrations."
       raise_error :change_column, rewrite_blocks: adapter.rewrite_blocks unless safe
     end
 
+    def check_change_column_default(*args)
+      table, column, _default_or_changes = args
+
+      # just check ActiveRecord::Base, even though can override on model
+      partial_inserts = ar_version >= 7 ? ActiveRecord::Base.partial_inserts : ActiveRecord::Base.partial_writes
+
+      if partial_inserts && !new_column?(table, column)
+        raise_error :change_column_default,
+          config: ar_version >= 7 ? "partial_inserts" : "partial_writes"
+      end
+    end
+
     def check_change_column_null(*args)
       table, column, null, default = args
       if !null
@@ -219,16 +259,22 @@ Then add the foreign key in separate migrations."
 
             add_constraint_code =
               if constraint_methods
-                # only quote when needed
-                expr_column = column.to_s =~ /\A[a-z0-9_]+\z/ ? column : connection.quote_column_name(column)
-                command_str(:add_check_constraint, [table, "#{expr_column} IS NOT NULL", {name: constraint_name, validate: false}])
+                command_str(:add_check_constraint, [table, "#{quote_column_if_needed(column)} IS NOT NULL", {name: constraint_name, validate: false}])
               else
                 safety_assured_str(add_code)
               end
 
+            validate_constraint_code =
+              if safe_with_check_constraint
+                down_code = "#{add_constraint_code}\n    #{command_str(:change_column_null, [table, column, true])}"
+                "def up\n    #{validate_constraint_code}\n  end\n\n  def down\n    #{down_code}\n  end"
+              else
+                "def change\n    #{validate_constraint_code}\n  end"
+              end
+
             raise_error :change_column_null_postgresql,
               add_constraint_code: add_constraint_code,
-              validate_constraint_code: "def change\n    #{validate_constraint_code}\n  end"
+              validate_constraint_code: validate_constraint_code
           end
         elsif mysql? || mariadb?
           unless adapter.strict_mode?
@@ -409,13 +455,29 @@ Then add the foreign key in separate migrations."
       "#{command} #{str_args.join(", ")}"
     end
 
-    def backfill_code(table, column, default)
+    def backfill_code(table, column, default, function = false)
       model = table.to_s.classify
-      "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
+      if function
+        # update_all(column: Arel.sql(default)) also works in newer versions of Active Record
+        update_expr = "#{quote_column_if_needed(column)} = #{default}"
+        "#{model}.unscoped.in_batches do |relation| \n      relation.where(#{column}: nil).update_all(#{update_expr.inspect})\n      sleep(0.01)\n    end"
+      else
+        "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
+      end
+    end
+
+    # only quote when needed
+    # important! only use for display purposes
+    def quote_column_if_needed(column)
+      column.to_s =~ /\A[a-z0-9_]+\z/ ? column : connection.quote_column_name(column)
     end
 
     def new_table?(table)
       @new_tables.include?(table.to_s)
     end
+
+    def new_column?(table, column)
+      new_table?(table) || @new_columns.include?([table.to_s, column.to_s])
+    end
   end
 end

data/lib/strong_migrations/error_messages.rb

@@ -1,7 +1,7 @@
 module StrongMigrations
   self.error_messages = {
     add_column_default:
-"Adding a column with a non-null default blocks %{rewrite_blocks} while the entire table is rewritten.
+"Adding a column with a %{default_type} default blocks %{rewrite_blocks} while the entire table is rewritten.
 Instead, add the column without a default value, then change the default.
 
 class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
@@ -25,6 +25,16 @@ class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
+    add_column_default_null:
+"Adding a column with a null default blocks %{rewrite_blocks} while the entire table is rewritten.
+Instead, add the column without a default value.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  end
+end",
+
     add_column_default_callable:
 "Strong Migrations does not support inspecting callable default values.
 Please make really sure you're not calling a VOLATILE function,
@@ -40,6 +50,9 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
+    add_column_generated_stored:
+"Adding a stored generated column blocks %{rewrite_blocks} while the entire table is rewritten.",
+
     change_column:
 "Changing the type of an existing column blocks %{rewrite_blocks}
 while the entire table is rewritten. A safer approach is to:
@@ -148,6 +161,13 @@ Otherwise, remove the force option.",
 execute call, so cannot help you here. Please make really sure that what
 you're doing is safe before proceeding, then wrap it in a safety_assured { ... } block.",
 
+    change_column_default:
+"Partial writes are enabled, which can cause incorrect values
+to be inserted when changing the default value of a column.
+Disable partial writes in config/application.rb:
+
+config.active_record.%{config} = false",
+
     change_column_null:
 "Passing a default value to change_column_null runs a single UPDATE query,
 which can cause downtime. Instead, backfill the existing rows in the
@@ -221,7 +241,10 @@ end",
 
     validate_check_constraint:
 "Validating a check constraint while writes are blocked is dangerous.
-Use disable_ddl_transaction! or a separate migration."
+Use disable_ddl_transaction! or a separate migration.",
+
+    add_exclusion_constraint:
+"Adding an exclusion constraint blocks reads and writes while every row is checked."
   }
   self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h
 end

data/lib/strong_migrations/safe_methods.rb

@@ -48,10 +48,20 @@ module StrongMigrations
         dir.up do
           @migration.add_foreign_key(from_table, to_table, *args, **options.merge(validate: false))
           disable_transaction
-          @migration.validate_foreign_key(from_table, to_table)
+          validate_options = options.slice(:column, :name)
+          if ActiveRecord::VERSION::MAJOR >= 6
+            @migration.validate_foreign_key(from_table, to_table, **validate_options)
+          else
+            @migration.validate_foreign_key(from_table, validate_options.any? ? validate_options : to_table)
+          end
         end
         dir.down do
-          @migration.remove_foreign_key(from_table, to_table)
+          remove_options = options.slice(:column, :name)
+          if ActiveRecord::VERSION::MAJOR >= 6
+            @migration.remove_foreign_key(from_table, to_table, **remove_options)
+          else
+            @migration.remove_foreign_key(from_table, remove_options.any? ? remove_options : to_table)
+          end
         end
       end
     end
@@ -64,7 +74,7 @@ module StrongMigrations
           @migration.validate_check_constraint(table, **validate_options)
         end
         dir.down do
-          @migration.remove_check_constraint(table, expression, **add_options)
+          @migration.remove_check_constraint(table, expression, **add_options.except(:validate))
         end
       end
     end

data/lib/strong_migrations/schema_dumper.rb

@@ -0,0 +1,21 @@
+module StrongMigrations
+  module SchemaDumper
+    def initialize(connection, *args, **options)
+      return super unless StrongMigrations.alphabetize_schema
+
+      super(WrappedConnection.new(connection), *args, **options)
+    end
+  end
+
+  class WrappedConnection
+    delegate_missing_to :@connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def columns(*args, **options)
+      @connection.columns(*args, **options).sort_by(&:name)
+    end
+  end
+end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "1.2.0"
+  VERSION = "1.6.0"
 end

data/lib/strong_migrations.rb

@@ -2,22 +2,22 @@
 require "active_support"
 
 # adapters
-require "strong_migrations/adapters/abstract_adapter"
-require "strong_migrations/adapters/mysql_adapter"
-require "strong_migrations/adapters/mariadb_adapter"
-require "strong_migrations/adapters/postgresql_adapter"
+require_relative "strong_migrations/adapters/abstract_adapter"
+require_relative "strong_migrations/adapters/mysql_adapter"
+require_relative "strong_migrations/adapters/mariadb_adapter"
+require_relative "strong_migrations/adapters/postgresql_adapter"
 
 # modules
-require "strong_migrations/checks"
-require "strong_migrations/safe_methods"
-require "strong_migrations/checker"
-require "strong_migrations/database_tasks"
-require "strong_migrations/migration"
-require "strong_migrations/migrator"
-require "strong_migrations/version"
+require_relative "strong_migrations/checks"
+require_relative "strong_migrations/safe_methods"
+require_relative "strong_migrations/checker"
+require_relative "strong_migrations/database_tasks"
+require_relative "strong_migrations/migration"
+require_relative "strong_migrations/migrator"
+require_relative "strong_migrations/version"
 
 # integrations
-require "strong_migrations/railtie" if defined?(Rails)
+require_relative "strong_migrations/railtie" if defined?(Rails)
 
 module StrongMigrations
   class Error < StandardError; end
@@ -28,7 +28,8 @@ module StrongMigrations
     attr_accessor :auto_analyze, :start_after, :checks, :error_messages,
       :target_postgresql_version, :target_mysql_version, :target_mariadb_version,
       :enabled_checks, :lock_timeout, :statement_timeout, :check_down, :target_version,
-      :safe_by_default, :target_sql_mode, :lock_timeout_retries, :lock_timeout_retry_delay
+      :safe_by_default, :target_sql_mode, :lock_timeout_retries, :lock_timeout_retry_delay,
+      :alphabetize_schema
     attr_writer :lock_timeout_limit
   end
   self.auto_analyze = false
@@ -38,10 +39,21 @@ module StrongMigrations
   self.checks = []
   self.safe_by_default = false
   self.check_down = false
+  self.alphabetize_schema = false
 
   # private
   def self.developer_env?
-    defined?(Rails) && (Rails.env.development? || Rails.env.test?)
+    env == "development" || env == "test"
+  end
+
+  # private
+  def self.env
+    if defined?(Rails.env)
+      Rails.env
+    else
+      # default to production for safety
+      ENV["RACK_ENV"] || "production"
+    end
   end
 
   def self.lock_timeout_limit
@@ -74,7 +86,7 @@ module StrongMigrations
 end
 
 # load error messages
-require "strong_migrations/error_messages"
+require_relative "strong_migrations/error_messages"
 
 ActiveSupport.on_load(:active_record) do
   ActiveRecord::Migration.prepend(StrongMigrations::Migration)
@@ -83,4 +95,7 @@ ActiveSupport.on_load(:active_record) do
   if defined?(ActiveRecord::Tasks::DatabaseTasks)
     ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(StrongMigrations::DatabaseTasks)
   end
+
+  require_relative "strong_migrations/schema_dumper"
+  ActiveRecord::SchemaDumper.prepend(StrongMigrations::SchemaDumper)
 end

data/lib/tasks/strong_migrations.rake

@@ -1,14 +1,9 @@
 namespace :strong_migrations do
-  # https://www.pgrs.net/2008/03/13/alphabetize-schema-rb-columns/
+  # https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/
   task :alphabetize_columns do
     $stderr.puts "Dumping schema"
     ActiveRecord::Base.logger.level = Logger::INFO
 
-    require "strong_migrations/alphabetize_columns"
-    ActiveRecord::Base.connection.class.prepend StrongMigrations::AlphabetizeColumns
-    if ActiveRecord::ConnectionAdapters.const_defined?('PostGISAdapter')
-      ActiveRecord::ConnectionAdapters::PostGISAdapter.prepend StrongMigrations::AlphabetizeColumns
-    end
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend StrongMigrations::AlphabetizeColumns
+    StrongMigrations.alphabetize_schema = true
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-10 00:00:00.000000000 Z
+date: 2023-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -45,7 +45,6 @@ files:
 - lib/strong_migrations/adapters/mariadb_adapter.rb
 - lib/strong_migrations/adapters/mysql_adapter.rb
 - lib/strong_migrations/adapters/postgresql_adapter.rb
-- lib/strong_migrations/alphabetize_columns.rb
 - lib/strong_migrations/checker.rb
 - lib/strong_migrations/checks.rb
 - lib/strong_migrations/database_tasks.rb
@@ -54,6 +53,7 @@ files:
 - lib/strong_migrations/migrator.rb
 - lib/strong_migrations/railtie.rb
 - lib/strong_migrations/safe_methods.rb
+- lib/strong_migrations/schema_dumper.rb
 - lib/strong_migrations/version.rb
 - lib/tasks/strong_migrations.rake
 homepage: https://github.com/ankane/strong_migrations
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Catch unsafe migrations in development

data/lib/strong_migrations/alphabetize_columns.rb

@@ -1,11 +0,0 @@
-module StrongMigrations
-  module AlphabetizeColumns
-    def columns(*args)
-      super.sort_by(&:name)
-    end
-
-    def extensions(*args)
-      super.sort
-    end
-  end
-end