strong_migrations 0.7.0 → 0.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ef314694846eec868e7e01b74fcfc9a29d361e01e3bc9102914a0bd3ba0facc
-  data.tar.gz: b27a43c73b0c394bd30579db15a412ade64d53fcc72a5d9a9b8fc35695d3aedd
+  metadata.gz: 38cd87929d4889113bc2cc13aa786965c8b86fadf05d1d0439e2c927becfef61
+  data.tar.gz: 0f17d511058c0bd1852adcddf9a2e978b8e407002ddf201be7aedb6c797dd294
 SHA512:
-  metadata.gz: 793918328d63451ef6a6ec3b90b3d2a4082ef2c57e018fa0f84e223defe506c3722f7e2168ef97854fcade562dc115943d9655954fdd9a319a13dca6ec50648b
-  data.tar.gz: c353256d7854ea1240bfc1e3f6e0ce7b8c76b72404f728c37695f923c4189777463481d57abc55efdce7a0326621a6a61ca9fcb98638e2f2aa279496d126bd20
+  metadata.gz: d28ef8e2d9cd837fac0a5e72743e1b88e7ef268ce9660e5119c27b50cc0e5215ae20e36a8be570a987e967f4a8bdf47ccd68eb6ee66f7188b787d3d64596c514
+  data.tar.gz: f1e012eed6af3ebcc0ffbf5a1f4b90438ee054597f41a9420a3645af8535fff4cb3ef64b69abdc547fbf20a14658b03f0492395ad46c6bfc79b26726424c81c4

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## 0.7.8 (2021-08-03)
+
+- Fixed issue with `add_reference ..., foreign_key: {to_table: ...}` with `safe_by_default`
+
+## 0.7.7 (2021-06-07)
+
+- Removed timeouts and `auto_analyze` from schema load
+
+## 0.7.6 (2021-01-17)
+
+- Fixed `NOT NULL` constraint check for quoted columns
+- Fixed deprecation warning with Active Record 6.1
+
+## 0.7.5 (2021-01-12)
+
+- Added checks for `add_check_constraint` and `validate_check_constraint`
+
+## 0.7.4 (2020-12-16)
+
+- Added `safe_by_default` option to install generator
+- Fixed warnings with Active Record 6.1
+
+## 0.7.3 (2020-11-24)
+
+- Added `safe_by_default` option
+
+## 0.7.2 (2020-10-25)
+
+- Added support for float timeouts
+
+## 0.7.1 (2020-07-27)
+
+- Added `target_version` option to replace database-specific options
+
 ## 0.7.0 (2020-07-22)
 
 - Added `check_down` option

data/LICENSE.txt

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

data/README.md

@@ -8,7 +8,7 @@ Supports for PostgreSQL, MySQL, and MariaDB
 
 :tangerine: Battle-tested at [Instacart](https://www.instacart.com/opensource)
 
-[![Build Status](https://travis-ci.org/ankane/strong_migrations.svg?branch=master)](https://travis-ci.org/ankane/strong_migrations)
+[![Build Status](https://github.com/ankane/strong_migrations/workflows/build/badge.svg?branch=master)](https://github.com/ankane/strong_migrations/actions)
 
 ## Installation
 
@@ -43,9 +43,9 @@ end
 
 Deploy the code, then wrap this step in a safety_assured { ... } block.
 
-class RemoveColumn < ActiveRecord::Migration[6.0]
+class RemoveColumn < ActiveRecord::Migration[6.1]
   def change
-    safety_assured { remove_column :users, :name, :string }
+    safety_assured { remove_column :users, :name }
   end
 end
 ```
@@ -66,6 +66,7 @@ Potentially dangerous operations:
 - [renaming 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)
+- [adding a check constraint](#adding-a-check-constraint)
 - [setting NOT NULL on an existing column](#setting-not-null-on-an-existing-column)
 - [executing SQL directly](#executing-SQL-directly)
 
@@ -89,7 +90,7 @@ You can also add [custom checks](#custom-checks) or [disable specific checks](#d
 Active Record caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
 
 ```ruby
-class RemoveSomeColumnFromUsers < ActiveRecord::Migration[6.0]
+class RemoveSomeColumnFromUsers < ActiveRecord::Migration[6.1]
   def change
     remove_column :users, :some_column
   end
@@ -110,7 +111,7 @@ end
 3. Write a migration to remove the column (wrap in `safety_assured` block)
 
   ```ruby
-  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[6.0]
+  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[6.1]
     def change
       safety_assured { remove_column :users, :some_column }
     end
@@ -126,7 +127,7 @@ end
 In earlier versions of Postgres, MySQL, and MariaDB, adding a column with a default value to an existing table 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[6.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[6.1]
   def change
     add_column :users, :some_column, :text, default: "default_value"
   end
@@ -140,7 +141,7 @@ In Postgres 11+, MySQL 8.0.12+, and MariaDB 10.3.2+, this no longer requires a t
 Instead, add the column without a default value, then change the default.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[6.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[6.1]
   def up
     add_column :users, :some_column, :text
     change_column_default :users, :some_column, "default_value"
@@ -161,7 +162,7 @@ See the next section for how to backfill.
 Active Record creates a transaction around each migration, and backfilling in the same transaction that alters a table keeps the table locked 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[6.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[6.1]
   def change
     add_column :users, :some_column, :text
     User.update_all some_column: "default_value"
@@ -176,7 +177,7 @@ Also, running a single query to update data can cause issues for large tables.
 There are three keys to backfilling safely: 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[6.0]
+class BackfillSomeColumn < ActiveRecord::Migration[6.1]
   disable_ddl_transaction!
 
   def up
@@ -195,7 +196,7 @@ end
 Changing the type of a 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 ChangeSomeColumnType < ActiveRecord::Migration[6.0]
+class ChangeSomeColumnType < ActiveRecord::Migration[6.1]
   def change
     change_column :users, :some_column, :new_type
   end
@@ -234,7 +235,7 @@ A safer approach is to:
 Renaming a column that’s in use will cause errors in your application.
 
 ```ruby
-class RenameSomeColumn < ActiveRecord::Migration[6.0]
+class RenameSomeColumn < ActiveRecord::Migration[6.1]
   def change
     rename_column :users, :some_column, :new_name
   end
@@ -259,7 +260,7 @@ A safer approach is to:
 Renaming a table that’s in use will cause errors in your application.
 
 ```ruby
-class RenameUsersToCustomers < ActiveRecord::Migration[6.0]
+class RenameUsersToCustomers < ActiveRecord::Migration[6.1]
   def change
     rename_table :users, :customers
   end
@@ -284,7 +285,7 @@ A safer approach is to:
 The `force` option can drop an existing table.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[6.0]
+class CreateUsers < ActiveRecord::Migration[6.1]
   def change
     create_table :users, force: true do |t|
       # ...
@@ -298,7 +299,7 @@ end
 Create tables without the `force` option.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[6.0]
+class CreateUsers < ActiveRecord::Migration[6.1]
   def change
     create_table :users do |t|
       # ...
@@ -309,14 +310,58 @@ end
 
 If you intend to drop an existing table, run `drop_table` first.
 
+### Adding a check constraint
+
+:turtle: Safe by default available
+
+#### Bad
+
+Adding a check constraint blocks reads and writes in Postgres and blocks writes in MySQL and MariaDB while every row is checked.
+
+```ruby
+class AddCheckConstraint < ActiveRecord::Migration[6.1]
+  def change
+    add_check_constraint :users, "price > 0", name: "price_check"
+  end
+end
+```
+
+#### Good - Postgres
+
+Add the check constraint without validating existing rows:
+
+```ruby
+class AddCheckConstraint < ActiveRecord::Migration[6.1]
+  def change
+    add_check_constraint :users, "price > 0", name: "price_check", validate: false
+  end
+end
+```
+
+Then validate them in a separate migration.
+
+```ruby
+class ValidateCheckConstraint < ActiveRecord::Migration[6.1]
+  def change
+    validate_check_constraint :users, name: "price_check"
+  end
+end
+```
+
+#### Good - MySQL and MariaDB
+
+[Let us know](https://github.com/ankane/strong_migrations/issues/new) if you have a safe way to do this (check constraints can be added with `NOT ENFORCED`, but enforcing blocks writes).
+
 ### Setting NOT NULL on an existing column
 
+:turtle: Safe by default available
+
 #### Bad
 
-Setting `NOT NULL` on an existing column blocks reads and writes while the every row is checked.
+Setting `NOT NULL` on an existing column blocks reads and writes while every row is checked.
 
 ```ruby
-class SetSomeColumnNotNull < ActiveRecord::Migration[6.0]
+class SetSomeColumnNotNull < ActiveRecord::Migration[6.1]
   def change
     change_column_null :users, :some_column, false
   end
@@ -325,7 +370,19 @@ end
 
 #### Good - Postgres
 
-Instead, add a check constraint:
+Instead, add a check constraint.
+
+For Rails 6.1, use:
+
+```ruby
+class SetSomeColumnNotNull < ActiveRecord::Migration[6.1]
+  def change
+    add_check_constraint :users, "some_column IS NOT NULL", name: "users_some_column_null", validate: false
+  end
+end
+```
+
+For Rails < 6.1, use:
 
 ```ruby
 class SetSomeColumnNotNull < ActiveRecord::Migration[6.0]
@@ -337,7 +394,23 @@ class SetSomeColumnNotNull < ActiveRecord::Migration[6.0]
 end
 ```
 
-Then validate it in a separate migration. A `NOT NULL` check constraint is [functionally equivalent](https://medium.com/doctolib/adding-a-not-null-constraint-on-pg-faster-with-minimal-locking-38b2c00c4d1c) to setting `NOT NULL` on the column, but it won’t show up in `schema.rb`. In Postgres 12+, once the check constraint is validated, you can safely set `NOT NULL` on the column and drop the check constraint.
+Then validate it in a separate migration. A `NOT NULL` check constraint is [functionally equivalent](https://medium.com/doctolib/adding-a-not-null-constraint-on-pg-faster-with-minimal-locking-38b2c00c4d1c) to setting `NOT NULL` on the column (but it won’t show up in `schema.rb` in Rails < 6.1). In Postgres 12+, once the check constraint is validated, you can safely set `NOT NULL` on the column and drop the check constraint.
+
+For Rails 6.1, use:
+
+```ruby
+class ValidateSomeColumnNotNull < ActiveRecord::Migration[6.1]
+  def change
+    validate_check_constraint :users, name: "users_some_column_null"
+
+    # in Postgres 12+, you can then safely set NOT NULL on the column
+    change_column_null :users, :some_column, false
+    remove_check_constraint :users, name: "users_some_column_null"
+  end
+end
+```
+
+For Rails < 6.1, use:
 
 ```ruby
 class ValidateSomeColumnNotNull < ActiveRecord::Migration[6.0]
@@ -364,7 +437,7 @@ end
 Strong Migrations can’t ensure safety for raw SQL statements. Make really sure that what you’re doing is safe, then use:
 
 ```ruby
-class ExecuteSQL < ActiveRecord::Migration[6.0]
+class ExecuteSQL < ActiveRecord::Migration[6.1]
   def change
     safety_assured { execute "..." }
   end
@@ -373,12 +446,14 @@ end
 
 ### Adding an index non-concurrently
 
+:turtle: Safe by default available
+
 #### Bad
 
 In Postgres, adding an index non-concurrently blocks writes.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[6.1]
   def change
     add_index :users, :some_column
   end
@@ -390,7 +465,7 @@ end
 Add indexes concurrently.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[6.1]
   disable_ddl_transaction!
 
   def change
@@ -409,12 +484,14 @@ rails g index table column
 
 ### Adding a reference
 
+:turtle: Safe by default available
+
 #### Bad
 
 Rails adds an index non-concurrently to references by default, which blocks writes in Postgres.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[6.0]
+class AddReferenceToUsers < ActiveRecord::Migration[6.1]
   def change
     add_reference :users, :city
   end
@@ -426,7 +503,7 @@ end
 Make sure the index is added concurrently.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[6.0]
+class AddReferenceToUsers < ActiveRecord::Migration[6.1]
   disable_ddl_transaction!
 
   def change
@@ -437,12 +514,14 @@ end
 
 ### Adding a foreign key
 
+:turtle: Safe by default available
+
 #### Bad
 
 In Postgres, adding a foreign key blocks writes on both tables.
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[6.0]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[6.1]
   def change
     add_foreign_key :users, :orders
   end
@@ -452,7 +531,7 @@ end
 or
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[6.0]
+class AddReferenceToUsers < ActiveRecord::Migration[6.1]
   def change
     add_reference :users, :order, foreign_key: true
   end
@@ -466,7 +545,7 @@ Add the foreign key without validating existing rows, then validate them in a se
 For Rails 5.2+, use:
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[6.0]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[6.1]
   def change
     add_foreign_key :users, :orders, validate: false
   end
@@ -476,7 +555,7 @@ end
 Then:
 
 ```ruby
-class ValidateForeignKeyOnUsers < ActiveRecord::Migration[6.0]
+class ValidateForeignKeyOnUsers < ActiveRecord::Migration[6.1]
   def change
     validate_foreign_key :users, :orders
   end
@@ -514,7 +593,7 @@ end
 In Postgres, there’s no equality operator for the `json` column type, which can cause errors for existing `SELECT DISTINCT` queries in your application.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[6.0]
+class AddPropertiesToUsers < ActiveRecord::Migration[6.1]
   def change
     add_column :users, :properties, :json
   end
@@ -526,7 +605,7 @@ end
 Use `jsonb` instead.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[6.0]
+class AddPropertiesToUsers < ActiveRecord::Migration[6.1]
   def change
     add_column :users, :properties, :jsonb
   end
@@ -540,7 +619,7 @@ end
 Adding a non-unique index with more than three columns rarely improves performance.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[6.1]
   def change
     add_index :users, [:a, :b, :c, :d]
   end
@@ -552,7 +631,7 @@ end
 Instead, start an index with columns that narrow down the results the most.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[6.1]
   def change
     add_index :users, [:b, :d]
   end
@@ -566,7 +645,7 @@ For Postgres, be sure to add them concurrently.
 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[6.0]
+class MySafeMigration < ActiveRecord::Migration[6.1]
   def change
     safety_assured { remove_column :users, :some_column }
   end
@@ -575,6 +654,21 @@ 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.
 
+## Safe by Default
+
+Make operations safe by default.
+
+- adding and removing an index
+- adding a foreign key
+- adding a check constraint
+- setting NOT NULL on an existing column
+
+Add to `config/initializers/strong_migrations.rb`:
+
+```ruby
+StrongMigrations.safe_by_default = true
+```
+
 ## Custom Checks
 
 Add your own custom checks with:
@@ -611,7 +705,7 @@ 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.
 
-## Down Migrations / Rollbacks [unreleased]
+## Down Migrations / Rollbacks
 
 By default, checks are disabled when migrating down. Enable them with:
 
@@ -707,11 +801,11 @@ Use the version from your latest migration.
 If your development database version is different from production, you can specify the production version so the right checks run in development.
 
 ```ruby
-StrongMigrations.target_postgresql_version = "10"
-StrongMigrations.target_mysql_version = "8.0.12"
-StrongMigrations.target_mariadb_version = "10.3.2"
+StrongMigrations.target_version = 10 # or "8.0.12", "10.3.2", etc
 ```
 
+The major version works well for Postgres, while the full version is recommended for MySQL and MariaDB.
+
 For safety, this option only affects development and test environments. In other environments, the actual server version is always used.
 
 ## Analyze Tables
@@ -724,11 +818,15 @@ StrongMigrations.auto_analyze = true
 
 ## Faster Migrations
 
-Only dump the schema when adding a new migration. If you use Git, create an initializer with:
+Only dump the schema when adding a new migration. If you use Git, add to the end of your `Rakefile`:
 
-```ruby
-ActiveRecord::Base.dump_schema_after_migration = Rails.env.development? &&
-  `git status db/migrate/ --porcelain`.present?
+```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"
 ```
 
 ## Schema Sanity

data/lib/generators/strong_migrations/install_generator.rb

@@ -12,6 +12,35 @@ module StrongMigrations
       def start_after
         Time.now.utc.strftime("%Y%m%d%H%M%S")
       end
+
+      def pgbouncer_message
+        if postgresql?
+          "\n# If you use PgBouncer in transaction mode, delete these lines and set timeouts on the database user"
+        end
+      end
+
+      def target_version
+        case adapter
+        when /mysql/
+          # could try to connect to database and check for MariaDB
+          # but this should be fine
+          '"8.0.12"'
+        else
+          "10"
+        end
+      end
+
+      def adapter
+        if ActiveRecord::VERSION::STRING.to_f >= 6.1
+          ActiveRecord::Base.connection_db_config.adapter.to_s
+        else
+          ActiveRecord::Base.connection_config[:adapter].to_s
+        end
+      end
+
+      def postgresql?
+        adapter =~ /postg/
+      end
     end
   end
 end

data/lib/generators/strong_migrations/templates/initializer.rb.tt

@@ -1,8 +1,7 @@
 # Mark existing migrations as safe
 StrongMigrations.start_after = <%= start_after %>
 
-# Set timeouts for migrations
-# If you use PgBouncer in transaction mode, delete these lines and set timeouts on the database user
+# Set timeouts for migrations<%= pgbouncer_message %>
 StrongMigrations.lock_timeout = 10.seconds
 StrongMigrations.statement_timeout = 1.hour
 
@@ -10,9 +9,17 @@ StrongMigrations.statement_timeout = 1.hour
 # Outdated statistics can sometimes hurt performance
 StrongMigrations.auto_analyze = true
 
+# Set the version of the production database
+# so the right checks are run in development
+# StrongMigrations.target_version = <%= target_version %>
+
 # Add custom checks
 # StrongMigrations.add_check do |method, args|
 #   if method == :add_index && args[0].to_s == "users"
 #     stop! "No more indexes on the users table"
 #   end
-# end
+# end<% if postgresql? %>
+
+# Make some operations safe by default
+# See https://github.com/ankane/strong_migrations#safe-by-default
+# StrongMigrations.safe_by_default = true<% end %>

data/lib/strong_migrations/checker.rb

@@ -1,6 +1,8 @@
 module StrongMigrations
   class Checker
-    attr_accessor :direction
+    include SafeMethods
+
+    attr_accessor :direction, :transaction_disabled
 
     def initialize(migration)
       @migration = migration
@@ -24,7 +26,7 @@ module StrongMigrations
       set_timeouts
       check_lock_timeout
 
-      unless safe?
+      if !safe? || safe_by_default_method?(method)
         case method
         when :remove_column, :remove_columns, :remove_timestamps, :remove_reference, :remove_belongs_to
           columns =
@@ -65,6 +67,7 @@ module StrongMigrations
             raise_error :add_index_columns, header: "Best practice"
           end
           if postgresql? && options[:algorithm] != :concurrently && !new_table?(table)
+            return safe_add_index(table, columns, options) if StrongMigrations.safe_by_default
             raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
           end
         when :remove_index
@@ -75,6 +78,7 @@ module StrongMigrations
           options ||= {}
 
           if postgresql? && options[:algorithm] != :concurrently && !new_table?(table)
+            return safe_remove_index(table, options) if StrongMigrations.safe_by_default
             raise_error :remove_index, command: command_str("remove_index", [table, options.merge(algorithm: :concurrently)])
           end
         when :add_column
@@ -184,14 +188,14 @@ Then add the NOT NULL constraint in separate migrations."
             bad_index = index_value && !concurrently_set
 
             if bad_index || options[:foreign_key]
-              columns = options[:polymorphic] ? [:"#{reference}_type", :"#{reference}_id"] : :"#{reference}_id"
-
               if index_value.is_a?(Hash)
                 options[:index] = options[:index].merge(algorithm: :concurrently)
               else
                 options = options.merge(index: {algorithm: :concurrently})
               end
 
+              return safe_add_reference(table, reference, options) if StrongMigrations.safe_by_default
+
               if options.delete(:foreign_key)
                 headline = "Adding a foreign key blocks writes on both tables."
                 append = "
@@ -215,22 +219,49 @@ Then add the foreign key in separate migrations."
             if postgresql?
               safe = false
               if postgresql_version >= Gem::Version.new("12")
-                # TODO likely need to quote the column in some situations
-                safe = constraints(table).any? { |c| c["def"] == "CHECK ((#{column} IS NOT NULL))" }
+                safe = constraints(table).any? { |c| c["def"] == "CHECK ((#{column} IS NOT NULL))" || c["def"] == "CHECK ((#{connection.quote_column_name(column)} IS NOT NULL))" }
               end
 
               unless safe
                 # match https://github.com/nullobject/rein
                 constraint_name = "#{table}_#{column}_null"
 
-                validate_constraint_code = String.new(constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table, constraint_name]))
+                add_code = constraint_str("ALTER TABLE %s ADD CONSTRAINT %s CHECK (%s IS NOT NULL) NOT VALID", [table, constraint_name, column])
+                validate_code = constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table, constraint_name])
+                remove_code = constraint_str("ALTER TABLE %s DROP CONSTRAINT %s", [table, constraint_name])
+
+                validate_constraint_code =
+                  if ar_version >= 6.1
+                    String.new(command_str(:validate_check_constraint, [table, {name: constraint_name}]))
+                  else
+                    String.new(safety_assured_str(validate_code))
+                  end
+
                 if postgresql_version >= Gem::Version.new("12")
-                  validate_constraint_code << "\n    #{command_str(:change_column_null, [table, column, null])}"
-                  validate_constraint_code << "\n    #{constraint_str("ALTER TABLE %s DROP CONSTRAINT %s", [table, constraint_name])}"
+                  change_args = [table, column, null]
+
+                  validate_constraint_code << "\n    #{command_str(:change_column_null, change_args)}"
+
+                  if ar_version >= 6.1
+                    validate_constraint_code << "\n    #{command_str(:remove_check_constraint, [table, {name: constraint_name}])}"
+                  else
+                    validate_constraint_code << "\n    #{safety_assured_str(remove_code)}"
+                  end
                 end
 
+                return safe_change_column_null(add_code, validate_code, change_args, remove_code) if StrongMigrations.safe_by_default
+
+                add_constraint_code =
+                  if ar_version >= 6.1
+                    # 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}])
+                  else
+                    safety_assured_str(add_code)
+                  end
+
                 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]),
+                  add_constraint_code: add_constraint_code,
                   validate_constraint_code: validate_constraint_code
               end
             elsif mysql? || mariadb?
@@ -245,20 +276,27 @@ Then add the foreign key in separate migrations."
           options ||= {}
 
           # always validated before 5.2
-          validate = options.fetch(:validate, true) || ActiveRecord::VERSION::STRING < "5.2"
+          validate = options.fetch(:validate, true) || ar_version < 5.2
 
           if postgresql? && validate
-            if ActiveRecord::VERSION::STRING < "5.2"
+            if ar_version < 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}"
 
+              add_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_code = constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [from_table, fk_name])
+
+              return safe_add_foreign_key_code(from_table, to_table, add_code, validate_code) if StrongMigrations.safe_by_default
+
               raise_error :add_foreign_key,
-                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])
+                add_foreign_key_code: safety_assured_str(add_code),
+                validate_foreign_key_code: safety_assured_str(validate_code)
             else
+              return safe_add_foreign_key(from_table, to_table, options) if StrongMigrations.safe_by_default
+
               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])
@@ -268,6 +306,29 @@ Then add the foreign key in separate migrations."
           if postgresql? && writes_blocked?
             raise_error :validate_foreign_key
           end
+        when :add_check_constraint
+          table, expression, options = args
+          options ||= {}
+
+          if !new_table?(table)
+            if postgresql? && options[:validate] != false
+              add_options = options.merge(validate: false)
+              name = options[:name] || @migration.check_constraint_options(table, expression, options)[:name]
+              validate_options = {name: name}
+
+              return safe_add_check_constraint(table, expression, add_options, validate_options) if StrongMigrations.safe_by_default
+
+              raise_error :add_check_constraint,
+                add_check_constraint_code: command_str("add_check_constraint", [table, expression, add_options]),
+                validate_check_constraint_code: command_str("validate_check_constraint", [table, validate_options])
+            elsif mysql? || mariadb?
+              raise_error :add_check_constraint_mysql
+            end
+          end
+        when :validate_check_constraint
+          if postgresql? && writes_blocked?
+            raise_error :validate_check_constraint
+          end
         end
 
         StrongMigrations.checks.each do |check|
@@ -279,11 +340,7 @@ Then add the foreign key in separate migrations."
 
       # outdated statistics + a new index can hurt performance of existing queries
       if StrongMigrations.auto_analyze && direction == :up && method == :add_index
-        if postgresql?
-          connection.execute "ANALYZE #{connection.quote_table_name(args[0].to_s)}"
-        elsif mariadb? || mysql?
-          connection.execute "ANALYZE TABLE #{connection.quote_table_name(args[0].to_s)}"
-        end
+        analyze_table(args[0])
       end
 
       result
@@ -298,7 +355,8 @@ Then add the foreign key in separate migrations."
             if postgresql?
               "SET statement_timeout TO #{connection.quote(postgresql_timeout(StrongMigrations.statement_timeout))}"
             elsif mysql?
-              "SET max_execution_time = #{connection.quote(StrongMigrations.statement_timeout.to_i * 1000)}"
+              # use ceil to prevent no timeout for values under 1 ms
+              "SET max_execution_time = #{connection.quote((StrongMigrations.statement_timeout.to_f * 1000).ceil)}"
             elsif mariadb?
               "SET max_statement_time = #{connection.quote(StrongMigrations.statement_timeout)}"
             else
@@ -334,8 +392,7 @@ Then add the foreign key in separate migrations."
     end
 
     def safe?
-      @safe || ENV["SAFETY_ASSURED"] || @migration.is_a?(ActiveRecord::Schema) ||
-        (direction == :down && !StrongMigrations.check_down) || version_safe?
+      @safe || ENV["SAFETY_ASSURED"] || (direction == :down && !StrongMigrations.check_down) || version_safe?
     end
 
     def version_safe?
@@ -380,6 +437,7 @@ Then add the foreign key in separate migrations."
     end
 
     def target_version(target_version)
+      target_version ||= StrongMigrations.target_version
       version =
         if target_version && StrongMigrations.developer_env?
           target_version.to_s
@@ -389,6 +447,10 @@ Then add the foreign key in separate migrations."
       Gem::Version.new(version)
     end
 
+    def ar_version
+      ActiveRecord::VERSION::STRING.to_f
+    end
+
     def check_lock_timeout
       limit = StrongMigrations.lock_timeout_limit
 
@@ -403,6 +465,7 @@ Then add the foreign key in separate migrations."
           end
         elsif mysql? || mariadb?
           lock_timeout = connection.select_all("SHOW VARIABLES LIKE 'lock_wait_timeout'").first["Value"]
+          # lock timeout is an integer
           if lock_timeout.to_i > limit
             warn "[strong_migrations] DANGER: Lock timeout is longer than #{limit} seconds: #{lock_timeout}"
           end
@@ -435,7 +498,16 @@ Then add the foreign key in separate migrations."
       if timeout.is_a?(String)
         timeout
       else
-        timeout.to_i * 1000
+        # use ceil to prevent no timeout for values under 1 ms
+        (timeout.to_f * 1000).ceil
+      end
+    end
+
+    def analyze_table(table)
+      if postgresql?
+        connection.execute "ANALYZE #{connection.quote_table_name(table.to_s)}"
+      elsif mariadb? || mysql?
+        connection.execute "ANALYZE TABLE #{connection.quote_table_name(table.to_s)}"
       end
     end
 
@@ -471,7 +543,10 @@ Then add the foreign key in separate migrations."
 
     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) }
+      statement % identifiers.map { |v| connection.quote_table_name(v) }
+    end
+
+    def safety_assured_str(code)
       "safety_assured do\n      execute '#{code}' \n    end"
     end
 

data/lib/strong_migrations/migration.rb

@@ -3,9 +3,12 @@ module StrongMigrations
     def migrate(direction)
       strong_migrations_checker.direction = direction
       super
+      connection.begin_db_transaction if strong_migrations_checker.transaction_disabled
     end
 
     def method_missing(method, *args)
+      return super if is_a?(ActiveRecord::Schema)
+
       strong_migrations_checker.perform(method, *args) do
         super
       end

data/lib/strong_migrations/safe_methods.rb

@@ -0,0 +1,129 @@
+module StrongMigrations
+  module SafeMethods
+    def safe_by_default_method?(method)
+      StrongMigrations.safe_by_default && [:add_index, :add_belongs_to, :add_reference, :remove_index, :add_foreign_key, :add_check_constraint, :change_column_null].include?(method)
+    end
+
+    # TODO check if invalid index with expected name exists and remove if needed
+    def safe_add_index(table, columns, options)
+      disable_transaction
+      @migration.add_index(table, columns, **options.merge(algorithm: :concurrently))
+    end
+
+    def safe_remove_index(table, options)
+      disable_transaction
+      @migration.remove_index(table, **options.merge(algorithm: :concurrently))
+    end
+
+    def safe_add_reference(table, reference, options)
+      @migration.reversible do |dir|
+        dir.up do
+          disable_transaction
+          foreign_key = options.delete(:foreign_key)
+          @migration.add_reference(table, reference, **options)
+          if foreign_key
+            # same as Active Record
+            name =
+              if foreign_key.is_a?(Hash) && foreign_key[:to_table]
+                foreign_key[:to_table]
+              else
+                (ActiveRecord::Base.pluralize_table_names ? reference.to_s.pluralize : reference).to_sym
+              end
+
+            if reference
+              @migration.add_foreign_key(table, name, column: "#{reference}_id")
+            else
+              @migration.add_foreign_key(table, name)
+            end
+          end
+        end
+        dir.down do
+          @migration.remove_reference(table, reference)
+        end
+      end
+    end
+
+    def safe_add_foreign_key(from_table, to_table, options)
+      @migration.reversible do |dir|
+        dir.up do
+          @migration.add_foreign_key(from_table, to_table, **options.merge(validate: false))
+          disable_transaction
+          @migration.validate_foreign_key(from_table, to_table)
+        end
+        dir.down do
+          @migration.remove_foreign_key(from_table, to_table)
+        end
+      end
+    end
+
+    def safe_add_foreign_key_code(from_table, to_table, add_code, validate_code)
+      @migration.reversible do |dir|
+        dir.up do
+          @migration.safety_assured do
+            @migration.execute(add_code)
+            disable_transaction
+            @migration.execute(validate_code)
+          end
+        end
+        dir.down do
+          @migration.remove_foreign_key(from_table, to_table)
+        end
+      end
+    end
+
+    def safe_add_check_constraint(table, expression, add_options, validate_options)
+      @migration.reversible do |dir|
+        dir.up do
+          @migration.add_check_constraint(table, expression, **add_options)
+          disable_transaction
+          @migration.validate_check_constraint(table, **validate_options)
+        end
+        dir.down do
+          @migration.remove_check_constraint(table, expression, **add_options)
+        end
+      end
+    end
+
+    def safe_change_column_null(add_code, validate_code, change_args, remove_code)
+      @migration.reversible do |dir|
+        dir.up do
+          @migration.safety_assured do
+            @migration.execute(add_code)
+            disable_transaction
+            @migration.execute(validate_code)
+          end
+          if change_args
+            @migration.change_column_null(*change_args)
+            @migration.safety_assured do
+              @migration.execute(remove_code)
+            end
+          end
+        end
+        dir.down do
+          if change_args
+            down_args = change_args.dup
+            down_args[2] = true
+            @migration.change_column_null(*down_args)
+          else
+            @migration.safety_assured do
+              @migration.execute(remove_code)
+            end
+          end
+        end
+      end
+    end
+
+    # hard to commit at right time when reverting
+    # so just commit at start
+    def disable_transaction
+      if in_transaction? && !transaction_disabled
+        @migration.connection.commit_db_transaction
+        self.transaction_disabled = true
+      end
+    end
+
+    def in_transaction?
+      @migration.connection.open_transactions > 0
+    end
+  end
+end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.7.0"
+  VERSION = "0.7.8"
 end

data/lib/strong_migrations.rb

@@ -2,6 +2,7 @@
 require "active_support"
 
 # modules
+require "strong_migrations/safe_methods"
 require "strong_migrations/checker"
 require "strong_migrations/database_tasks"
 require "strong_migrations/migration"
@@ -17,12 +18,14 @@ module StrongMigrations
   class << self
     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
+      :enabled_checks, :lock_timeout, :statement_timeout, :check_down, :target_version,
+      :safe_by_default
     attr_writer :lock_timeout_limit
   end
   self.auto_analyze = false
   self.start_after = 0
   self.checks = []
+  self.safe_by_default = false
   self.error_messages = {
     add_column_default:
 "Adding a column with a non-null default blocks %{rewrite_blocks} while the entire table is rewritten.
@@ -213,6 +216,30 @@ end",
 
     validate_foreign_key:
 "Validating a foreign key while writes are blocked is dangerous.
+Use disable_ddl_transaction! or a separate migration.",
+
+    add_check_constraint:
+"Adding a check constraint key blocks reads and writes while every row is checked.
+Instead, add the check constraint without validating existing rows,
+then validate them in a separate migration.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_check_constraint_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_check_constraint_code}
+  end
+end",
+
+    add_check_constraint_mysql:
+"Adding a check constraint to an existing table is not safe with your database engine.",
+
+    validate_check_constraint:
+"Validating a check constraint while writes are blocked is dangerous.
 Use disable_ddl_transaction! or a separate migration."
   }
   self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.8
 platform: ruby
 authors:
 - Andrew Kane
 - Bob Remeika
 - David Waller
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-23 00:00:00.000000000 Z
+date: 2021-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -96,7 +96,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - andrew@chartkick.com
 - bob.remeika@gmail.com
@@ -116,13 +116,14 @@ files:
 - lib/strong_migrations/database_tasks.rb
 - lib/strong_migrations/migration.rb
 - lib/strong_migrations/railtie.rb
+- lib/strong_migrations/safe_methods.rb
 - lib/strong_migrations/version.rb
 - lib/tasks/strong_migrations.rake
 homepage: https://github.com/ankane/strong_migrations
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -137,8 +138,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Catch unsafe migrations in development
 test_files: []