strong_migrations 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbb45da961375e9a3499c6b651da754c164f05b0e33f9b5061a856ce508663b6
-  data.tar.gz: 1718eb87c7eb8b60553b1e800e8a4866cdbc134ae9c062e012caa6e8f3d4be6b
+  metadata.gz: d4a27bb71eb7436386540b0f86fb17d3bf82f2e100eff8e836acb842d22ffab6
+  data.tar.gz: 81b1f63c48a92599e7d421adbbd22411e26a467c052520dd1ee0982d2e150f6a
 SHA512:
-  metadata.gz: 63dde3000e42dbe433914159a815a1dc4a1ebca89e78f3f342e9aa664bd1e921bbb3a1ee33140d6e56d50aef400b171e27a24509fd369da0350b0f548a108a25
-  data.tar.gz: d187c338c085b86ad7498ea09253a9d2015415740b4c09d78ec1f9f37abbc20261255b1590210d7bbf473fcb2ecfa1bad57a9e356a9e2480ec2f90d9fb355404
+  metadata.gz: 27f6188cf4fdb6391a3f5e7926e292029c9ae47260010349ee93fa908d7abd74a40b2ac6d9bc7970f1e9c0b35c85c60b0c8719b125ee32dac3903190823483cf
+  data.tar.gz: 5682113d7f4a56a11cf9c9dfe3bcefb373c101737bf8073970f1a56eb87efeb79e0a648c6908d7f8f77adf3ed68690a7b4523a43abef149ef09b8cff945ea8e2

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.4.0
+
+- Added check for `add_foreign_key`
+- Fixed instructions for adding default value with NOT NULL constraint
+- Removed support for Rails 4.2
+
 ## 0.3.1
 
 - Fixed error with `remove_column` and `type` argument

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Bob Remeika and David Waller, 2015-2018 Andrew Kane
+Copyright (c) 2013 Bob Remeika and David Waller, 2015-2019 Andrew Kane
 
 MIT License
 

data/README.md

@@ -16,51 +16,88 @@ gem 'strong_migrations'
 
 ## How It Works
 
-Strong Migrations detects potentially dangerous operations in migrations, prevents them from running by default, and provides instructions on safer ways to do what you want. Here’s an example:
+Strong Migrations detects potentially dangerous operations in migrations, prevents them from running by default, and provides instructions on safer ways to do what you want.
 
-```
-=== Dangerous operation detected #strong_migrations ===
+![Screenshot](https://ankane.org/images/strong-migrations.png)
 
-ActiveRecord caches attributes which causes problems
-when removing columns. Be sure to ignore the column:
+## Dangerous Operations
 
-class User < ApplicationRecord
-  self.ignored_columns = ["some_column"]
-end
+The following operations can cause downtime or errors:
+
+- [[+]](#removing-a-column) removing a column
+- [[+]](#adding-a-column-with-a-default-value) adding a column with a non-null default value to an existing table
+- [[+]](#backfilling-data) backfilling data
+- [[+]](#adding-an-index) adding an index non-concurrently
+- [[+]](#adding-a-reference) adding a reference
+- [[+]](#adding-a-foreign-key) adding a foreign key
+- [[+]](#renaming-or-changing-the-type-of-a-column) changing the type of a column
+- [[+]](#renaming-or-changing-the-type-of-a-column) renaming a column
+- [[+]](#renaming-a-table) renaming a table
+- [[+]](#creating-a-table-with-the-force-option) creating a table with the `force` option
+- [[+]](#using-change_column_null-with-a-default-value) using `change_column_null` with a default value
+- [[+]](#adding-a-json-column) adding a `json` column
+
+Also checks for best practices:
 
-Deploy the code, then wrap this step in a safety_assured { ... } block.
+- [[+]](#) keeping non-unique indexes to three columns or less
 
-class RemoveColumn < ActiveRecord::Migration[5.2]
+## The Zero Downtime Way
+
+### Removing a column
+
+#### Bad
+
+ActiveRecord caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
+
+```ruby
+class RemoveSomeColumnFromUsers < ActiveRecord::Migration[5.2]
   def change
-    safety_assured { remove_column :users, :some_column }
+    remove_column :users, :some_column
   end
 end
 ```
 
-## Dangerous Operations
+#### Good
 
-The following operations can cause downtime or errors:
+1. Tell ActiveRecord to ignore the column from its cache
 
-- adding a column with a non-null default value to an existing table
-- removing a column
-- changing the type of a column
-- setting a `NOT NULL` constraint with a default value
-- renaming a column
-- renaming a table
-- creating a table with the `force` option
-- adding an index non-concurrently (Postgres only)
-- adding a `json` column to an existing table (Postgres only)
+  ```ruby
+  class User < ApplicationRecord
+    self.ignored_columns = ["some_column"]
+  end
+  ```
 
-Also checks for best practices:
+2. Deploy code
+3. Write a migration to remove the column (wrap in `safety_assured` block)
 
-- keeping non-unique indexes to three columns or less
+  ```ruby
+  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[5.2]
+    def change
+      safety_assured { remove_column :users, :some_column }
+    end
+  end
+  ```
 
-## The Zero Downtime Way
+4. Deploy and run migration
 
 ### Adding a column with a default value
 
+#### Bad
+
 Adding a column with a non-null default causes the entire table to be rewritten.
 
+```ruby
+class AddSomeColumnToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_column :users, :some_column, :text, default: "default_value"
+  end
+end
+```
+
+> This operation is safe in Postgres 11+
+
+#### Good
+
 Instead, add the column without a default value, then change the default.
 
 ```ruby
@@ -76,65 +113,191 @@ class AddSomeColumnToUsers < ActiveRecord::Migration[5.2]
 end
 ```
 
-Don’t backfill existing rows in this migration, as it can cause downtime. See the next section for how to do it safely.
-
-> With Postgres, this operation is safe as of Postgres 11
+See the next section for how to backfill.
 
 ### Backfilling data
 
-To backfill data, use the Rails console or a separate migration with `disable_ddl_transaction!`. Avoid backfilling in a transaction, especially one that alters a table. See [this great article](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/) on why.
+#### Bad
+
+Backfilling in the same transaction that alters a table locks the table for the [duration of the backfill](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/).
+
+```ruby
+class AddSomeColumnToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_column :users, :some_column, :text
+    User.update_all some_column: "default_value"
+  end
+end
+```
+
+Also, running a single query to update data can cause issues for large tables.
+
+#### Good
+
+There are three keys: batching, throttling, and running it outside a transaction. Use the Rails console or a separate migration with `disable_ddl_transaction!`.
 
 ```ruby
 class BackfillSomeColumn < ActiveRecord::Migration[5.2]
   disable_ddl_transaction!
 
   def change
-    # Rails 5+
-    User.in_batches.update_all some_column: "default_value"
-
-    # Rails < 5
-    User.find_in_batches do |records|
-      User.where(id: records.map(&:id)).update_all some_column: "default_value"
+    User.in_batches do |relation|
+      relation.update_all some_column: "default_value"
+      sleep(0.1) # throttle
     end
   end
 end
 ```
 
-### Removing a column
+### Adding an index
 
-ActiveRecord caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots. To prevent this:
+#### Bad
 
-1. Tell ActiveRecord to ignore the column from its cache
+In Postgres, adding a non-concurrent indexes lock the table.
 
-  ```ruby
-  # For Rails 5+
-  class User < ApplicationRecord
-    self.ignored_columns = ["some_column"]
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_index :users, :some_column
   end
+end
+```
 
-  # For Rails < 5
-  class User < ActiveRecord::Base
-    def self.columns
-      super.reject { |c| c.name == "some_column" }
-    end
+#### Good
+
+Add indexes concurrently.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def change
+    add_index :users, :some_column, algorithm: :concurrently
   end
-  ```
+end
+```
 
-2. Deploy code
-3. Write a migration to remove the column (wrap in `safety_assured` block)
+If you forget `disable_ddl_transaction!`, the migration will fail. Also, note that indexes on new tables (those created in the same migration) don’t require this. Check out [gindex](https://github.com/ankane/gindex) to quickly generate index migrations without memorizing the syntax.
 
-  ```ruby
-  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[5.2]
-    def change
-      safety_assured { remove_column :users, :some_column }
+### Adding a reference
+
+#### Bad
+
+Rails adds a non-concurrent index to references by default, which is problematic for Postgres.
+
+```ruby
+class AddReferenceToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_reference :users, :city
+  end
+end
+```
+
+#### Good
+
+Make sure the index is added concurrently.
+
+```ruby
+class AddReferenceToUsers < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def change
+    add_reference :users, :city, index: false
+    add_index :users, :city_id, algorithm: :concurrently
+  end
+end
+```
+
+For polymorphic references, add a compound index on type and id.
+
+### Adding a foreign key
+
+#### Bad
+
+In Postgres, new foreign keys are validated by default, which acquires an `AccessExclusiveLock` that can be [expensive on large tables](https://travisofthenorth.com/blog/2017/2/2/postgres-adding-foreign-keys-with-zero-downtime).
+
+```ruby
+class AddForeignKeyOnUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_foreign_key :users, :orders
+  end
+end
+```
+
+#### Good
+
+Instead, validate it in a separate migration with a more agreeable `RowShareLock`. This approach is documented by Postgres to have “[the least impact on other work](https://www.postgresql.org/docs/current/sql-altertable.html).”
+
+For Rails 5.2+, use:
+
+```ruby
+class AddForeignKeyOnUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_foreign_key :users, :orders, validate: false
+  end
+end
+```
+
+Then validate it in a separate migration.
+
+```ruby
+class ValidateForeignKeyOnUsers < ActiveRecord::Migration[5.2]
+  def change
+    validate_foreign_key :users, :orders
+  end
+end
+```
+
+For Rails < 5.2, use:
+
+```ruby
+class AddForeignKeyOnUsers < ActiveRecord::Migration[5.1]
+  def change
+    safety_assured do
+      execute 'ALTER TABLE "users" ADD CONSTRAINT "fk_rails_c1e9b98e31" FOREIGN KEY ("order_id") REFERENCES "orders" ("id") NOT VALID'
     end
   end
-  ```
+end
+```
 
-4. Deploy and run migration
+Then validate it in a separate migration.
+
+```ruby
+class ValidateForeignKeyOnUsers < ActiveRecord::Migration[5.1]
+  def change
+    safety_assured do
+      execute 'ALTER TABLE "users" VALIDATE CONSTRAINT "fk_rails_c1e9b98e31"'
+    end
+  end
+end
+```
 
 ### Renaming or changing the type of a column
 
+#### Bad
+
+```ruby
+class RenameSomeColumn < ActiveRecord::Migration[5.2]
+  def change
+    rename_column :users, :some_column, :new_name
+  end
+end
+```
+
+or
+
+```ruby
+class ChangeSomeColumnType < ActiveRecord::Migration[5.2]
+  def change
+    change_column :users, :some_column, :new_type
+  end
+end
+```
+
+One exception is changing a `varchar` column to `text`, which is safe in Postgres.
+
+#### Good
+
 A safer approach is to:
 
 1. Create a new column
@@ -144,10 +307,20 @@ A safer approach is to:
 5. Stop writing to the old column
 6. Drop the old column
 
-One exception is changing a `varchar` column to `text`, which is safe in Postgres 9.1+.
-
 ### Renaming a table
 
+#### Bad
+
+```ruby
+class RenameUsersToCustomers < ActiveRecord::Migration[5.2]
+  def change
+    rename_table :users, :customers
+  end
+end
+```
+
+#### Good
+
 A safer approach is to:
 
 1. Create a new table
@@ -157,64 +330,119 @@ A safer approach is to:
 5. Stop writing to the old table
 6. Drop the old table
 
-### Adding an index (Postgres)
+### Creating a table with the `force` option
 
-Add indexes concurrently.
+#### Bad
+
+The `force` option can drop an existing table.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
-  disable_ddl_transaction!
+class CreateUsers < ActiveRecord::Migration[5.2]
+  def change
+    create_table :users, force: true do |t|
+      # ...
+    end
+  end
+end
+```
+
+#### Good
+
+If you intend to drop a table, do it explicitly. Then create the new table without the `force` option:
 
+```ruby
+class CreateUsers < ActiveRecord::Migration[5.2]
   def change
-    add_index :users, :some_column, algorithm: :concurrently
+    create_table :users do |t|
+      # ...
+    end
   end
 end
 ```
 
-If you forget `disable_ddl_transaction!`, the migration will fail. Also, note that indexes on new tables (those created in the same migration) don’t require this. Check out [gindex](https://github.com/ankane/gindex) to quickly generate index migrations without memorizing the syntax.
+### Using `change_column_null` with a default value
+
+#### Bad
 
-Rails 5+ adds an index to references by default. To make sure this happens concurrently, use:
+This generates a single `UPDATE` statement to set the default value.
 
 ```ruby
-class AddSomeReferenceToUsers < ActiveRecord::Migration[5.2]
-  disable_ddl_transaction!
+class ChangeSomeColumnNull < ActiveRecord::Migration[5.2]
+  def change
+    change_column_null :users, :some_column, false, "default_value"
+  end
+end
+```
 
+#### Good
+
+Backfill the column [safely](#backfilling-data). Then use:
+
+```ruby
+class ChangeSomeColumnNull < ActiveRecord::Migration[5.2]
   def change
-    add_reference :users, :reference, index: false
-    add_index :users, :reference_id, algorithm: :concurrently
+    change_column_null :users, :some_column, false
   end
 end
 ```
 
-For polymorphic references, add a compound index on type and id.
+### Adding a json column
 
-### Adding a json column (Postgres)
+#### Bad
 
-There’s no equality operator for the `json` column type, which causes issues for `SELECT DISTINCT` queries.
+In Postgres, there’s no equality operator for the `json` column type, which causes issues for `SELECT DISTINCT` queries.
+
+```ruby
+class AddPropertiesToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_column :users, :properties, :json
+  end
+end
+```
 
-If you’re on Postgres 9.4+, use `jsonb` instead.
+#### Good
 
-If you must use `json`, replace all calls to `uniq` with a custom scope.
+Use `jsonb` instead.
 
 ```ruby
-class User < ApplicationRecord
-  scope :uniq_on_id, -> { select("DISTINCT ON (users.id) users.*") }
+class AddPropertiesToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_column :users, :properties, :jsonb
+  end
 end
 ```
 
-Then add the column:
+## Best Practices
+
+### Keeping non-unique indexes to three columns or less
+
+#### Bad
+
+Adding an index with more than three columns only helps on extremely large tables.
 
 ```ruby
-class AddJsonColumnToUsers < ActiveRecord::Migration[5.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
   def change
-    safety_assured { add_column :users, :some_column, :json }
+    add_index :users, [:a, :b, :c, :d]
   end
 end
 ```
 
+#### Good
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
+  def change
+    add_index :users, [:a, :b, :c]
+  end
+end
+```
+
+> For Postgres, be sure to add them concurrently
+
 ## Assuring Safety
 
-To mark a step in the migration as safe, despite using method that might otherwise be dangerous, wrap it in a `safety_assured` block.
+To mark a step in the migration as safe, despite using a method that might otherwise be dangerous, wrap it in a `safety_assured` block.
 
 ```ruby
 class MySafeMigration < ActiveRecord::Migration[5.2]
@@ -224,6 +452,8 @@ class MySafeMigration < ActiveRecord::Migration[5.2]
 end
 ```
 
+Certain methods like `execute` and `change_table` cannot be inspected and are prevented from running by default. Make sure what you’re doing is really safe and use this pattern.
+
 ## Custom Checks
 
 Add your own custom checks with:
@@ -238,6 +468,8 @@ end
 
 Use the `stop!` method to stop migrations.
 
+> Since `remove_column` always requires a `safety_assured` block, it’s not possible to add a custom check for `remove_column` operations
+
 ## Existing Migrations
 
 To mark migrations as safe that were created before installing this gem, create an initializer with:
@@ -312,7 +544,7 @@ Rails 5.1+ uses `bigint` for primary keys to keep you from running out of ids. T
 
 ## Credits
 
-Thanks to Bob Remeika and David Waller for the [original code](https://github.com/foobarfighter/safe-migrations).
+Thanks to Bob Remeika and David Waller for the [original code](https://github.com/foobarfighter/safe-migrations) and [Sean Huber](https://github.com/LendingHome/zero_downtime_migrations) for the bad/good readme format.
 
 ## Contributing
 

data/lib/strong_migrations/migration.rb

@@ -15,8 +15,6 @@ module StrongMigrations
 
     def method_missing(method, *args, &block)
       unless @safe || ENV["SAFETY_ASSURED"] || is_a?(ActiveRecord::Schema) || @direction == :down || version_safe?
-        ar5 = ActiveRecord::VERSION::MAJOR >= 5
-
         case method
         when :remove_column, :remove_columns, :remove_timestamps, :remove_reference, :remove_belongs_to
           columns =
@@ -36,7 +34,7 @@ module StrongMigrations
               cols
             end
 
-          code = ar5 ? "self.ignored_columns = #{columns.inspect}" : "def self.columns\n    super.reject { |c| #{columns.inspect}.include?(c.name) }\n  end"
+          code = "self.ignored_columns = #{columns.inspect}"
 
           raise_error :remove_column,
             model: args[0].to_s.classify,
@@ -65,21 +63,30 @@ module StrongMigrations
           default = options[:default]
 
           if !default.nil? && !(postgresql? && postgresql_version >= 110000)
+
+            if options[:null] == false
+              options = options.except(:null)
+              append = "
+
+Then add the NOT NULL constraint.
+
+class %{migration_name}NotNull < ActiveRecord::Migration%{migration_suffix}
+  def change
+    #{command_str("change_column_null", [table, column, false])}
+  end
+end"
+            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)
+              code: backfill_code(table, column, default),
+              append: append
           end
 
           if type.to_s == "json" && postgresql?
-            if postgresql_version >= 90400
-              raise_error :add_column_json
-            else
-              raise_error :add_column_json_legacy,
-                model: table.to_s.classify,
-                table: connection.quote_table_name(table.to_s)
-            end
+            raise_error :add_column_json
           end
         when :change_column
           table, column, type = args
@@ -103,7 +110,7 @@ module StrongMigrations
           table, reference, options = args
           options ||= {}
 
-          index_value = options.fetch(:index, ar5)
+          index_value = options.fetch(:index, true)
           if postgresql? && index_value
             columns = options[:polymorphic] ? [:"#{reference}_type", :"#{reference}_id"] : :"#{reference}_id"
 
@@ -119,6 +126,32 @@ module StrongMigrations
             raise_error :change_column_null,
               code: backfill_code(table, column, default)
           end
+        when :add_foreign_key
+          from_table, to_table, options = args
+          options ||= {}
+          validate = options.fetch(:validate, true)
+
+          if postgresql?
+            if ActiveRecord::VERSION::STRING >= "5.2"
+              if validate
+                raise_error :add_foreign_key,
+                  add_foreign_key_code: command_str("add_foreign_key", [from_table, to_table, options.merge(validate: false)]),
+                  validate_foreign_key_code: command_str("validate_foreign_key", [from_table, to_table])
+              end
+            else
+              # always validated before 5.2
+
+              # fk name logic from rails
+              primary_key = options[:primary_key] || "id"
+              column = options[:column] || "#{to_table.to_s.singularize}_id"
+              hashed_identifier = Digest::SHA256.hexdigest("#{from_table}_#{column}_fk").first(10)
+              fk_name = options[:name] || "fk_rails_#{hashed_identifier}"
+
+              raise_error :add_foreign_key,
+                add_foreign_key_code: foreign_key_str("ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s) NOT VALID", [from_table, fk_name, column, to_table, primary_key]),
+                validate_foreign_key_code: foreign_key_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [from_table, fk_name])
+            end
+          end
         end
 
         StrongMigrations.checks.each do |check|
@@ -152,15 +185,25 @@ module StrongMigrations
     def raise_error(message_key, header: nil, **vars)
       message = StrongMigrations.error_messages[message_key] || "Missing message"
 
-      ar5 = ActiveRecord::VERSION::MAJOR >= 5
       vars[:migration_name] = self.class.name
-      vars[:migration_suffix] = ar5 ? "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" : ""
-      vars[:base_model] = ar5 ? "ApplicationRecord" : "ActiveRecord::Base"
+      vars[:migration_suffix] = "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      vars[:base_model] = "ApplicationRecord"
+
+      # interpolate variables in appended code
+      if vars[:append]
+        vars[:append] = vars[:append].gsub(/%(?!{)/, "%%") % vars
+      end
 
       # escape % not followed by {
       stop!(message.gsub(/%(?!{)/, "%%") % vars, header: header || "Dangerous operation detected")
     end
 
+    def foreign_key_str(statement, identifiers)
+      # not all identifiers are tables, but this method of quoting should be fine
+      code = statement % identifiers.map { |v| connection.quote_table_name(v) }
+      "safety_assured do\n      execute '#{code}' \n    end"
+    end
+
     def command_str(command, args)
       str_args = args[0..-2].map { |a| a.inspect }
 
@@ -179,11 +222,7 @@ module StrongMigrations
 
     def backfill_code(table, column, default)
       model = table.to_s.classify
-      if ActiveRecord::VERSION::MAJOR >= 5
-        "#{model}.in_batches.update_all #{column}: #{default.inspect}"
-      else
-        "#{model}.find_in_batches do |records|\n      #{model}.where(id: records.map(&:id)).update_all #{column}: #{default.inspect}\n    end"
-      end
+      "#{model}.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.1)\n    end"
     end
 
     def stop!(message, header: "Custom check")

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/strong_migrations.rb

@@ -37,23 +37,12 @@ class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   def change
     %{code}
   end
-end",
+end%{append}",
 
     add_column_json:
 "There's no equality operator for the json column type, which
 causes issues for SELECT DISTINCT queries. Use jsonb instead.",
 
-    add_column_json_legacy:
-"There's no equality operator for the json column type, which.
-causes issues for SELECT DISTINCT queries.
-Replace all calls to uniq with a custom scope.
-
-class %{model} < %{base_model}
-  scope :uniq_on_id, -> { select('DISTINCT ON (%{table}.id) %{table}.*') }
-end
-
-Once it's deployed, wrap this step in a safety_assured { ... } block.",
-
     change_column:
 "Changing the type of an existing column requires the entire
 table and indexes to be rewritten. A safer approach is to:
@@ -93,7 +82,7 @@ end",
     rename_table:
 "Renaming a table is dangerous. A safer approach is to:
 
-1. Create a new table
+1. Create a new table. Don't forget to recreate indexes from the old table
 2. Write to both tables
 3. Backfill data from the old table to new table
 4. Move reads from the old table to the new table
@@ -143,7 +132,7 @@ 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_null:
+    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
 Rails console or a separate migration with disable_ddl_transaction!.
@@ -154,7 +143,24 @@ class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   def change
     %{code}
   end
-end"
+end",
+
+    add_foreign_key:
+"New foreign keys are validated by default. This acquires an AccessExclusiveLock,
+which is expensive on large tables. Instead, validate it in a separate migration
+with a more agreeable RowShareLock.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_foreign_key_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_foreign_key_code}
+  end
+end",
   }
 
   def self.add_check(&block)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-19 00:00:00.000000000 Z
+date: 2019-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -72,16 +72,16 @@ dependencies:
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
 description: 
 email:
 - andrew@chartkick.com
@@ -114,15 +114,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Catch unsafe migrations at dev time