strong_migrations 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a77b960928e0167e1842dbd337dc0e47ecae009fec7e6b13cdfba539cb2addc5
-  data.tar.gz: 154e03c69d7790a81051bf55b0d2a04a0a1ce0ed83d347f5a44f7255f950f794
+  metadata.gz: 372efa1cc2267462dd7294cf7d39cd710941b223df3d38ec4d24fd7a91feb7ad
+  data.tar.gz: '0139953c4aee0b08a15e9169af644eca36aa3ecd49d5c7c23a678d7423c35233'
 SHA512:
-  metadata.gz: 90839d0e1af71af600a220dd689262c6472190d437a61e97da40bd79c7ec5f4d418d45c2b3ff88514e3ab1ceca8cc04bb912f1f3e6553ba3efac53eb6d171992
-  data.tar.gz: bbf6f7b9645391d8fdaa54b8edf59904d2f75c806bcd7d0940eb762cc102c2355fafa231114d20a1cb8cae603eea807fd654868da3f6f40846a8fe022bd58778
+  metadata.gz: b1d8049950bb0a8d38d01479b5a00e6ca9ed80878d2a7b8d21a8217efaf51e7727793d82845c9287c4e18619aa4a36d581b69de47e8ab48f16612ebf9188601c
+  data.tar.gz: 7b9f3a70ec40ffa42fe8e2928998de861cca4bcbdb23ad3ad9134b4fea09cc0228439b32cb8ec19910d5faf6f331445ba692bca1b8d0a5681d1d77df78554374

data/CHANGELOG.md

@@ -1,93 +1,99 @@
-## 0.4.2
+## 0.5.0 (2019-12-05)
+
+- Added ability to disable checks
+- Added Postgres-specific check for `change_column_null`
+- Added optional remove index check
+
+## 0.4.2 (2019-10-27)
 
 - Allow `add_reference` with concurrent indexes
 
-## 0.4.1
+## 0.4.1 (2019-07-12)
 
 - Added `target_postgresql_version`
 - Added `unscoped` to backfill instructions
 
-## 0.4.0
+## 0.4.0 (2019-05-27)
 
 - 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
+## 0.3.1 (2018-10-18)
 
 - Fixed error with `remove_column` and `type` argument
 - Improved message customization
 
-## 0.3.0
+## 0.3.0 (2018-10-15)
 
 - Added support for custom checks
 - Adding a column with a non-null default value is safe in Postgres 11+
 - Added checks for `add_belongs_to`, `remove_belongs_to`, `remove_columns`, and `remove_reference`
 - Customized messages
 
-## 0.2.3
+## 0.2.3 (2018-07-22)
 
 - Added check for `change_column_null`
 - Added support for alphabetize columns with Makara
 - Fixed migration reversibility with `auto_analyze`
 
-## 0.2.2
+## 0.2.2 (2018-02-14)
 
 - Friendlier output
 - Better method of hooking into ActiveRecord
 
-## 0.2.1
+## 0.2.1 (2018-02-07)
 
 - Recommend `disable_ddl_transaction!` over `commit_db_transaction`
 - Suggest `jsonb` over `json` in Postgres 9.4+
 - Changing `varchar` to `text` is safe in Postgres 9.1+
 - Do not check number of columns for unique indexes
 
-## 0.2.0
+## 0.2.0 (2018-01-07)
 
 - Added customizable error messages
 - Updated instructions for adding a column with a default value
 
-## 0.1.9
+## 0.1.9 (2017-06-14)
 
 - Added `start_after` option
 
-## 0.1.8
+## 0.1.8 (2017-05-31)
 
 - Fixed error with `create_table`
 - Added check for executing arbitrary SQL
 
-## 0.1.7
+## 0.1.7 (2017-05-29)
 
 - Added check for `force` option with `create_table`
 - Added `auto_analyze` option
 
-## 0.1.6
+## 0.1.6 (2017-03-23)
 
 - Adding an index to a newly created table is now safe
 
-## 0.1.5
+## 0.1.5 (2016-07-23)
 
 - Fixed error with Ruby 2.3 frozen strings
 
-## 0.1.4
+## 0.1.4 (2016-03-22)
 
 - Added alphabetize columns
 
-## 0.1.3
+## 0.1.3 (2016-03-12)
 
 - Disabled dangerous rake tasks in production
 - Added ability to use `SAFETY_ASSURED` env var
 
-## 0.1.2
+## 0.1.2 (2016-02-24)
 
 - Skip checks on down migrations and rollbacks
 - Added check for indexes with more than 3 columns
 
-## 0.1.1
+## 0.1.1 (2015-11-29)
 
 - Fixed `add_index` check for MySQL
 
-## 0.1.0
+## 0.1.0 (2015-11-22)
 
 - First release

data/README.md

@@ -34,10 +34,14 @@ The following operations can cause downtime or errors:
 - [[+]](#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
+- [[+]](#using-change_column_null) using `change_column_null`
 - [[+]](#adding-a-json-column) adding a `json` column
 
-Also checks for best practices:
+Optional checks:
+
+- [[+]](#removing-an-index) removing an index non-concurrently
+
+Best practices:
 
 - [[+]](#keeping-non-unique-indexes-to-three-columns-or-less) keeping non-unique indexes to three columns or less
 
@@ -82,6 +86,8 @@ end
 
 ### Adding a column with a default value
 
+Note: This operation is safe in Postgres 11+.
+
 #### Bad
 
 Adding a column with a default value to an existing table causes the entire table to be rewritten.
@@ -94,8 +100,6 @@ class AddSomeColumnToUsers < ActiveRecord::Migration[6.0]
 end
 ```
 
-> This operation is safe in Postgres 11+
-
 #### Good
 
 Instead, add the column without a default value, then change the default.
@@ -153,7 +157,7 @@ end
 
 #### Bad
 
-In Postgres, adding a non-concurrent index locks the table.
+In Postgres, adding an index non-concurrently locks the table.
 
 ```ruby
 class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
@@ -183,7 +187,7 @@ If you forget `disable_ddl_transaction!`, the migration will fail. Also, note th
 
 #### Bad
 
-Rails adds a non-concurrent index to references by default, which is problematic for Postgres.
+Rails adds an index non-concurrently to references by default, which is problematic for Postgres.
 
 ```ruby
 class AddReferenceToUsers < ActiveRecord::Migration[6.0]
@@ -207,13 +211,11 @@ class AddReferenceToUsers < ActiveRecord::Migration[6.0]
 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).
+In Postgres, new foreign keys are validated by default, which acquires a `ShareRowExclusiveLock` 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[6.0]
@@ -359,7 +361,49 @@ class CreateUsers < ActiveRecord::Migration[6.0]
 end
 ```
 
-### Using change_column_null with a default value
+### Using change_column_null
+
+#### Bad
+
+In Postgres, setting `NOT NULL` on an existing column requires an `AccessExclusiveLock`, which is expensive on large tables.
+
+```ruby
+class SetSomeColumnNotNull < ActiveRecord::Migration[6.0]
+  def change
+    change_column_null :users, :some_column, false
+  end
+end
+```
+
+#### Good
+
+Instead, add a constraint:
+
+```ruby
+class SetSomeColumnNotNull < ActiveRecord::Migration[6.0]
+  def change
+    safety_assured do
+      execute 'ALTER TABLE "users" ADD CONSTRAINT "users_some_column_null" CHECK ("some_column" IS NOT NULL) NOT VALID'
+    end
+  end
+end
+```
+
+Then validate it in a separate migration.
+
+```ruby
+class ValidateSomeColumnNotNull < ActiveRecord::Migration[6.0]
+  def change
+    safety_assured do
+      execute 'ALTER TABLE "users" VALIDATE CONSTRAINT "users_some_column_null"'
+    end
+  end
+end
+```
+
+Note: This is not 100% the same as `NOT NULL` column constraint. Here’s a [good explanation](https://medium.com/doctolib/adding-a-not-null-constraint-on-pg-faster-with-minimal-locking-38b2c00c4d1c).
+
+### Using change_column_null with a default value (non-Postgres)
 
 #### Bad
 
@@ -385,11 +429,13 @@ class ChangeSomeColumnNull < ActiveRecord::Migration[6.0]
 end
 ```
 
+Note: In Postgres, `change_column_null` is still [not safe](#using-change_column_null) with this method.
+
 ### Adding a json column
 
 #### Bad
 
-In Postgres, 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 can cause errors for existing `SELECT DISTINCT` queries.
 
 ```ruby
 class AddPropertiesToUsers < ActiveRecord::Migration[6.0]
@@ -411,6 +457,48 @@ class AddPropertiesToUsers < ActiveRecord::Migration[6.0]
 end
 ```
 
+## Optional Checks
+
+Some operations rarely cause issues in practice, but can be checked if desired. Enable checks with:
+
+```ruby
+StrongMigrations.enable_check(:remove_index)
+```
+
+To start a check only after a specific migration, use:
+
+```ruby
+StrongMigrations.enable_check(:remove_index, start_after: 20170101000000)
+```
+
+### Removing an index
+
+#### Bad
+
+In Postgres, removing an index non-concurrently locks the table for a brief period.
+
+```ruby
+class RemoveSomeIndexFromUsers < ActiveRecord::Migration[6.0]
+  def change
+    remove_index :users, :some_column
+  end
+end
+```
+
+#### Good
+
+Remove indexes concurrently.
+
+```ruby
+class RemoveSomeIndexFromUsers < ActiveRecord::Migration[6.0]
+  disable_ddl_transaction!
+
+  def change
+    remove_index :users, column: :some_column, algorithm: :concurrently
+  end
+end
+```
+
 ## Best Practices
 
 ### Keeping non-unique indexes to three columns or less
@@ -439,7 +527,7 @@ class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
 end
 ```
 
-> For Postgres, be sure to add them concurrently
+For Postgres, be sure to add them concurrently.
 
 ## Assuring Safety
 
@@ -469,7 +557,17 @@ 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
+Note: Since `remove_column` always requires a `safety_assured` block, it’s not possible to add a custom check for `remove_column` operations.
+
+## Disable Checks
+
+Disable specific checks with:
+
+```ruby
+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.
 
 ## Existing Migrations
 
@@ -500,7 +598,7 @@ ActiveRecord::Base.dump_schema_after_migration = Rails.env.development? &&
 
 ## 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/13/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 the end of your `Rakefile`:
 
 ```ruby
 task "db:schema:dump": "strong_migrations:alphabetize_columns"

data/lib/strong_migrations.rb

@@ -9,7 +9,7 @@ require "strong_migrations/version"
 
 module StrongMigrations
   class << self
-    attr_accessor :auto_analyze, :start_after, :checks, :error_messages, :target_postgresql_version
+    attr_accessor :auto_analyze, :start_after, :checks, :error_messages, :target_postgresql_version, :enabled_checks
   end
   self.auto_analyze = false
   self.start_after = 0
@@ -41,8 +41,8 @@ class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
 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.",
+"There's no equality operator for the json column type, which can
+cause errors for existing SELECT DISTINCT queries. Use jsonb instead.",
 
     change_column:
 "Changing the type of an existing column requires the entire
@@ -91,7 +91,7 @@ end",
 6. Drop the old table",
 
     add_reference:
-"Adding a non-concurrent index locks the table. Instead, use:
+"Adding an index non-concurrently locks the table. Instead, use:
 
 class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
@@ -102,7 +102,18 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
 end",
 
     add_index:
-"Adding a non-concurrent index locks the table. Instead, use:
+"Adding an index non-concurrently locks the table. Instead, use:
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def change
+    %{command}
+  end
+end",
+
+    remove_index:
+"Removing an index non-concurrently locks the table. Instead, use:
 
 class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
@@ -144,6 +155,23 @@ class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
+    change_column_null_postgresql:
+"Setting NOT NULL on a column requires an AccessExclusiveLock,
+which is expensive on large tables. Instead, use a constraint and
+validate it in a separate migration with a more agreeable RowShareLock.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_constraint_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_constraint_code}
+  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
@@ -161,10 +189,28 @@ class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
   }
+  self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h
 
   def self.add_check(&block)
     checks << block
   end
+
+  def self.enable_check(check, start_after: nil)
+    enabled_checks[check] = {start_after: start_after}
+  end
+
+  def self.disable_check(check)
+    enabled_checks.delete(check)
+  end
+
+  def self.check_enabled?(check, version: nil)
+    if enabled_checks[check]
+      start_after = enabled_checks[check][:start_after] || StrongMigrations.start_after
+      !version || version > start_after
+    else
+      false
+    end
+  end
 end
 
 ActiveSupport.on_load(:active_record) do

data/lib/strong_migrations/checker.rb

@@ -59,9 +59,19 @@ module StrongMigrations
           if columns.is_a?(Array) && columns.size > 3 && !options[:unique]
             raise_error :add_index_columns, header: "Best practice"
           end
-          if postgresql? && options[:algorithm] != :concurrently && !@new_tables.include?(table.to_s)
+          if postgresql? && options[:algorithm] != :concurrently && !new_table?(table)
             raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
           end
+        when :remove_index
+          table, options = args
+          unless options.is_a?(Hash)
+            options = {column: options}
+          end
+          options ||= {}
+
+          if postgresql? && options[:algorithm] != :concurrently && !new_table?(table)
+            raise_error :remove_index, command: command_str("remove_index", [table, options.merge(algorithm: :concurrently)])
+          end
         when :add_column
           table, column, type, options = args
           options ||= {}
@@ -73,13 +83,7 @@ module StrongMigrations
               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"
+Then add the NOT NULL constraint."
             end
 
             raise_error :add_column_default,
@@ -133,9 +137,18 @@ end"
           raise_error :execute, header: "Possibly dangerous operation"
         when :change_column_null
           table, column, null, default = args
-          if !null && !default.nil?
-            raise_error :change_column_null,
-              code: backfill_code(table, column, default)
+          if !null
+            if postgresql?
+              # match https://github.com/nullobject/rein
+              constraint_name = "#{table}_#{column}_null"
+
+              raise_error :change_column_null_postgresql,
+                add_constraint_code: constraint_str("ALTER TABLE %s ADD CONSTRAINT %s CHECK (%s IS NOT NULL) NOT VALID", [table, constraint_name, column]),
+                validate_constraint_code: constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table, constraint_name])
+            elsif !default.nil?
+              raise_error :change_column_null,
+                code: backfill_code(table, column, default)
+            end
           end
         when :add_foreign_key
           from_table, to_table, options = args
@@ -159,8 +172,8 @@ end"
               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])
+                add_foreign_key_code: constraint_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: constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [from_table, fk_name])
             end
           end
         end
@@ -214,6 +227,8 @@ end"
     end
 
     def raise_error(message_key, header: nil, **vars)
+      return unless StrongMigrations.check_enabled?(message_key, version: version)
+
       message = StrongMigrations.error_messages[message_key] || "Missing message"
 
       vars[:migration_name] = self.class.name
@@ -229,7 +244,7 @@ end"
       @migration.stop!(message.gsub(/%(?!{)/, "%%") % vars, header: header || "Dangerous operation detected")
     end
 
-    def foreign_key_str(statement, identifiers)
+    def constraint_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"
@@ -262,5 +277,9 @@ end"
       model = table.to_s.classify
       "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.1)\n    end"
     end
+
+    def new_table?(table)
+      @new_tables.include?(table.to_s)
+    end
   end
 end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-28 00:00:00.000000000 Z
+date: 2019-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord