pg_ha_migrations 1.1.0 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b472247321efcc716bc1f7c4e497dcbe32058e4d2ce11d8f6d0d9fea7136755
-  data.tar.gz: 820bf96e3200deb2cffd30ba5534513600d05138f57f7812539cc8b33f96058a
+  metadata.gz: f6bc07b7a31ace17d8b98c1a4cd2d6c23086e81da40cc3ef6c27006effa29114
+  data.tar.gz: 0dafb9db37d66f7723cb96d38cbd44cc3747f61f8c2c7695f51a64559ff3b3fb
 SHA512:
-  metadata.gz: b95318b6bf16ea1f5c9ec2514a6d6cccf912fc051caa9a954c58a038431d9afbbf01a23576f4ceaab1856922dc6e9aee5573743abb619f494c0f6023dcb217a9
-  data.tar.gz: 8bf47117312865cf57b51d200f3d131c266171a0f9899f39b8aa3f09aad50842555d93007a0b33a00873a7d67ec56a0f9b9027a028bf28338399939cd285ceda
+  metadata.gz: 973a40f102ede133528abe11ff9bbe89104d0ca47f2b2e8d36436ab241adddd5c3cc575d57e5bc33aaf37006bd5046df0cad530671b515b5ae6b64b904870b52
+  data.tar.gz: c386d4f0ee49f49ef31514556fb93a7554356a440899e3641a91071b0cdebbe6900f5c7e1df20803f2c6eb8a4259b6c1039676523b4a18b551ef30ee9e8c1cc5

data/.github/workflows/ci.yml

@@ -0,0 +1,41 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      matrix:
+        pg:
+          - 9.6
+          - 10
+          - 11
+          - 12
+        gemfile:
+          - rails_5.0
+          - rails_5.1
+          - rails_5.2
+          - rails_6.0
+    name: PostgreSQL ${{ matrix.pg }}
+    runs-on: ubuntu-latest
+    env: # $BUNDLE_GEMFILE must be set at the job level, so it is set for all steps
+      BUNDLE_GEMFILE: gemfiles/${{ matrix.gemfile }}.gemfile
+      ImageOS: ubuntu20
+    services:
+      postgresql:
+        image: postgres:${{ matrix.pg }}
+        env:
+          POSTGRES_PASSWORD: postgres
+        # Set health checks to wait until postgres has started
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Ruby using .ruby-version file
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - run: bundle exec rake spec

data/.gitignore

@@ -7,6 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/gemfiles/*.lock
 
 # rspec failure tracking
 .rspec_status

data/.ruby-version

@@ -1 +1 @@
-ruby-2.4.3
+ruby-2.7

data/.travis.yml

@@ -1,11 +1,27 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.4
+  - 2.5
+env:
+  jobs:
+    - PGVERSION: "9.6"
+    - PGVERSION: "10"
+    - PGVERSION: "11"
+    - PGVERSION: "12"
 services:
   - postgresql
-addons:
-  postgresql: "9.6"
 before_install:
+  - "for CLUSTER_VERSION in $(pg_lsclusters -h | cut -d' ' -f1); do sudo pg_dropcluster $CLUSTER_VERSION main --stop || true; done"
+  - sudo apt-get update
+  - sudo apt-get -y install postgresql-$PGVERSION postgresql-client-$PGVERSION postgresql-server-dev-$PGVERSION postgresql-client-common postgresql-common
+  - sudo pg_dropcluster $PGVERSION main --stop || true
+  - sudo pg_createcluster $PGVERSION main -D /var/ramfs/postgresql/11/main -- --auth=trust
+  - sudo pg_ctlcluster start $PGVERSION main
   - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
   - gem install bundler -v 1.15.4
+gemfile:
+  - gemfiles/rails_5.0.gemfile
+  - gemfiles/rails_5.1.gemfile
+  - gemfiles/rails_5.2.gemfile
+  - gemfiles/rails_6.0.gemfile
+script: "bundle exec rake spec"

data/Appraisals

@@ -0,0 +1,16 @@
+appraise "rails-5.0" do
+  gem "rails", "5.0.7.2"
+end
+
+appraise "rails-5.1" do
+  gem "rails", "5.1.7"
+end
+
+appraise "rails-5.2" do
+  gem "rails", "5.2.3"
+end
+
+appraise "rails-6.0" do
+  gem "rails", "6.0.0"
+end
+

data/README.md

@@ -55,7 +55,7 @@ There are two major classes of concerns we try to handle in the API:
 
 We rename migration methods with prefixes denoting their safety level:
 
-- `safe_*`: These methods check for both application and database safety concerns prefer concurrent operations where available, set low lock timeouts where appropriate, and decompose operations into multiple safe steps.
+- `safe_*`: These methods check for both application and database safety concerns, prefer concurrent operations where available, set low lock timeouts where appropriate, and decompose operations into multiple safe steps.
 - `unsafe_*`: These methods are generally a direct dispatch to the native ActiveRecord migration method.
 
 Calling the original migration methods without a prefix will raise an error.
@@ -106,6 +106,18 @@ Safely add a new enum value.
 safe_add_enum_value :enum, "value"
 ```
 
+#### unsafe\_rename\_enum\_value
+
+Unsafely change the value of an enum type entry.
+
+```ruby
+unsafe_rename_enum_value(:enum, "old_value", "new_value")
+```
+
+Note:
+
+Changing an enum value does not issue any long-running scans or acquire locks on usages of the enum type. Therefore multiple queries within a transaction concurrent with the change may see both the old and new values. To highlight these potential pitfalls no `safe_rename_enum_value` equivalent exists. Before modifying an enum type entry you should verify that no concurrently executing queries will attempt to write the old value and that read queries understand the new value.
+
 #### safe\_add\_column
 
 Safely add a column.
@@ -127,7 +139,13 @@ unsafe_add_column :table, :column, :type
 Safely change the default value for a column.
 
 ```ruby
+# Constant value:
 safe_change_column_default :table, :column, "value"
+safe_change_column_default :table, :column, DateTime.new(...)
+# Functional expression evaluated at row insert time:
+safe_change_column_default :table, :column, -> { "NOW()" }
+# Functional expression evaluated at migration time:
+safe_change_column_default :table, :column, -> { "'NOW()'" }
 ```
 
 #### safe\_make\_column\_nullable
@@ -168,6 +186,37 @@ Safely remove an index. Migrations that contain this statement must also include
 safe_remove_concurrent_index :table, :name => :index_name
 ```
 
+#### safe\_add\_unvalidated\_check\_constraint
+
+Safely add a `CHECK` constraint. The constraint will not be immediately validated on existing rows to avoid a full table scan while holding an exclusive lock. After adding the constraint, you'll need to use `safe_validate_check_constraint` to validate existing rows.
+
+```ruby
+safe_add_unvalidated_check_constraint :table, "column LIKE 'example%'", name: :constraint_table_on_column_like_example
+```
+
+#### safe\_validate\_check\_constraint
+
+Safely validate (without acquiring an exclusive lock) existing rows for a newly added but as-yet unvalidated `CHECK` constraint.
+
+```ruby
+safe_validate_check_constraint :table, name: :constraint_table_on_column_like_example
+```
+
+#### safe\_rename\_constraint
+
+Safely rename any (not just `CHECK`) constraint.
+
+```ruby
+safe_rename_constraint :table, from: :constraint_table_on_column_like_typo, to: :constraint_table_on_column_like_example
+```
+
+#### unsafe\_remove\_constraint
+
+Drop any (not just `CHECK`) constraint.
+
+```ruby
+unsafe_remove_constraint :table, name: :constraint_table_on_column_like_example
+```
 
 ### Utilities
 
@@ -246,7 +295,7 @@ Rake::Task["pg_ha_migrations:check_blocking_database_transactions"].enhance ["db
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies and start a postgres docker container. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies and start a postgres docker container. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. This project uses Appraisal to test against multiple versions of ActiveRecord; you can run the tests against all supported version with `bundle exec appraisal rspec`.
 
 Running tests will automatically create a test database in the locally running Postgres server. You can find the connection parameters in `spec/spec_helper.rb`, but setting the environment variables `PGHOST`, `PGPORT`, `PGUSER`, and `PGPASSWORD` will override the defaults.
 

data/Rakefile

@@ -1,8 +1,13 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "appraisal"
 require_relative File.join("lib", "pg_ha_migrations")
 
 RSpec::Core::RakeTask.new(:spec)
 
+if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
+    task :default => :appraisal
+end
+
 task :default => :spec
 

data/bin/setup

@@ -4,6 +4,7 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
+bundle exec appraisal install
 
 # Do any other automated setup that you need to do here
 

data/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_RETRY: "1"

data/gemfiles/rails_5.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.0.7.2"
+
+gemspec path: "../"

data/gemfiles/rails_5.1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.1.7"
+
+gemspec path: "../"

data/gemfiles/rails_5.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.2.3"
+
+gemspec path: "../"

data/gemfiles/rails_6.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "6.0.0"
+
+gemspec path: "../"

data/lib/pg_ha_migrations.rb

@@ -35,6 +35,10 @@ module PgHaMigrations
   # as expected or get the schema into an inconsistent state
   InvalidMigrationError = Class.new(Exception)
 
+  # Unsupported migrations use ActiveRecord::Migration features that
+  # we don't support, and therefore will likely have unexpected behavior.
+  UnsupportedMigrationError = Class.new(Exception)
+
   # This gem only supports the PostgreSQL adapter at this time.
   UnsupportedAdapter = Class.new(Exception)
 end
@@ -47,13 +51,14 @@ require "pg_ha_migrations/dependent_objects_checks"
 require "pg_ha_migrations/allowed_versions"
 require "pg_ha_migrations/railtie"
 require "pg_ha_migrations/hacks/disable_ddl_transaction"
+require "pg_ha_migrations/hacks/cleanup_unnecessary_output"
 
 module PgHaMigrations::AutoIncluder
   def inherited(klass)
     super(klass) if defined?(super)
 
-    klass.prepend(PgHaMigrations::SafeStatements)
     klass.prepend(PgHaMigrations::UnsafeStatements)
+    klass.prepend(PgHaMigrations::SafeStatements)
   end
 end
 

data/lib/pg_ha_migrations/allowed_versions.rb

@@ -1,7 +1,7 @@
 require "active_record/migration/compatibility"
 
 module PgHaMigrations::AllowedVersions
-  ALLOWED_VERSIONS = [4.2, 5.0, 5.1, 5.2].map do |v|
+  ALLOWED_VERSIONS = [4.2, 5.0, 5.1, 5.2, 6.0].map do |v|
     begin
       ActiveRecord::Migration[v]
     rescue ArgumentError

data/lib/pg_ha_migrations/blocking_database_transactions.rb

@@ -1,13 +1,23 @@
 module PgHaMigrations
   class BlockingDatabaseTransactions
-    LongRunningTransaction = Struct.new(:database, :current_query, :transaction_age, :tables_with_locks) do
+    LongRunningTransaction = Struct.new(:database, :current_query, :state, :transaction_age, :tables_with_locks) do
       def description
-        "#{database} | tables (#{tables_with_locks.join(', ')}) have been locked for #{transaction_age} | query: #{current_query}"
+        locked_tables = tables_with_locks.compact
+        [
+          database,
+          locked_tables.size > 0 ? "tables (#{locked_tables.join(', ')})" : nil,
+          "#{idle? ? "currently idle " : ""}transaction open for #{transaction_age}",
+          "#{idle? ? "last " : ""}query: #{current_query}"
+        ].compact.join(" | ")
       end
 
       def concurrent_index_creation?
         !!current_query.match(/create\s+index\s+concurrently/i)
       end
+
+      def idle?
+        state == "idle in transaction"
+      end
     end
 
     def self.autovacuum_regex
@@ -15,35 +25,48 @@ module PgHaMigrations
     end
 
     def self.find_blocking_transactions(minimum_transaction_age = "0 seconds")
-      pid_column, state_column = if ActiveRecord::Base.connection.select_value("SHOW server_version") =~ /9\.1/
+      postgres_version = ActiveRecord::Base.connection.postgresql_version
+      pid_column, query_column = if postgres_version < 9_02_00
         ["procpid", "current_query"]
       else
         ["pid", "query"]
       end
 
-      raw_query = <<-SQL
+      # In some versions of Postgres, walsenders show up here with a non-null xact_start.
+      # That's been patched, so hard to test, but we should exclude them anyway.
+      # https://www.postgresql.org/message-id/flat/20191209234409.exe7osmyalwkt5j4%40development
+      ignore_sqlsender_sql = "psa.backend_type != 'walsender'"
+
+      raw_query = <<~SQL
         SELECT
           psa.datname as database, -- Will only ever be one database
-          psa.#{state_column} as current_query,
+          psa.#{query_column} as current_query,
+          psa.state,
           clock_timestamp() - psa.xact_start AS transaction_age,
           array_agg(distinct c.relname) AS tables_with_locks
         FROM pg_stat_activity psa -- Cluster wide
-          JOIN pg_locks l ON (psa.#{pid_column} = l.pid)  -- Cluster wide
-          JOIN pg_class c ON (l.relation = c.oid) -- Database wide
-          JOIN pg_namespace ns ON (c.relnamespace = ns.oid) -- Database wide
-        WHERE psa.#{pid_column} != pg_backend_pid()
-          AND ns.nspname != 'pg_catalog'
-          AND c.relkind = 'r'
-          AND psa.xact_start < clock_timestamp() - ?::interval
-          AND psa.#{state_column} !~ ?
-          AND (
+          LEFT JOIN pg_locks l ON (psa.#{pid_column} = l.pid)  -- Cluster wide
+          LEFT JOIN pg_class c ON ( -- Database wide
+            l.locktype = 'relation'
+            AND l.relation = c.oid
             -- Be explicit about this being for a single database -- it's already implicit in
             -- the relations used, and if we don't restrict this we could get incorrect results
             -- with oid collisions from pg_namespace and pg_class.
-            l.database = 0
-            OR l.database = (SELECT d.oid FROM pg_database d WHERE d.datname = current_database())
+            AND l.database = (SELECT d.oid FROM pg_database d WHERE d.datname = current_database())
           )
-        GROUP BY psa.datname, psa.#{state_column}, psa.xact_start
+          LEFT JOIN pg_namespace ns ON (c.relnamespace = ns.oid) -- Database wide
+        WHERE psa.#{pid_column} != pg_backend_pid()
+          AND (
+            l.locktype != 'relation'
+            OR (
+               ns.nspname != 'pg_catalog'
+               AND c.relkind = 'r'
+            )
+          )
+          AND psa.xact_start < clock_timestamp() - ?::interval
+          AND psa.#{query_column} !~ ?
+          #{postgres_version >= 10_00_00 ? "AND #{ignore_sqlsender_sql}" : ""}
+        GROUP BY psa.datname, psa.#{query_column}, psa.state, psa.xact_start
       SQL
 
       query = ActiveRecord::Base.send(:sanitize_sql_for_conditions, [raw_query, minimum_transaction_age, autovacuum_regex])

data/lib/pg_ha_migrations/blocking_database_transactions_reporter.rb

@@ -24,7 +24,7 @@ module PgHaMigrations
         end
 
         if blocking_transactions.any?(&:concurrent_index_creation?)
-          report << <<-eos.strip_heredoc.lines.map { |line| "\t#{line}" }.join
+          report << <<~eos.lines.map { |line| "\t#{line}" }.join
             Warning: concurrent indexes are currently being built. If you have any other
                      migrations in this deploy that will attempt to create additional
                      concurrent indexes on the same physical database (even if the table

data/lib/pg_ha_migrations/hacks/cleanup_unnecessary_output.rb

@@ -0,0 +1,29 @@
+require "active_record/migration/compatibility"
+
+module PgHaMigrations
+  module ActiveRecordHacks
+    module CleanupUnnecessaryOutput
+      # This is fixed in Rails 6+, but previously there were several
+      # places where #adapter_name was called directly which implicitly
+      # delegated to the connection through #method_missing. That
+      # delegation though results in wrapping the call in #say_with_time
+      # which unnecessarily outputs a bunch of calls to #adapter_name.
+      # The easiest way to clean this up retroactively is to just patch
+      # in a direct dispatch to the connection's method.
+      #
+      # See: https://github.com/rails/rails/commit/eb7c71bcd3d0c7e079dffdb11e43fb466eec06aa
+      def adapter_name
+        connection.adapter_name
+      end
+    end
+  end
+end
+
+patchable_module = [
+ defined?(ActiveRecord::Migration::Compatibility::V5_2) ? ActiveRecord::Migration::Compatibility::V5_2 : nil,
+ defined?(ActiveRecord::Migration::Compatibility::V5_1) ? ActiveRecord::Migration::Compatibility::V5_1 : nil,
+ defined?(ActiveRecord::Migration::Compatibility::V5_0) ? ActiveRecord::Migration::Compatibility::V5_0 : nil,
+].detect { |m| m }
+if patchable_module
+  patchable_module.prepend(PgHaMigrations::ActiveRecordHacks::CleanupUnnecessaryOutput)
+end

data/lib/pg_ha_migrations/safe_statements.rb

@@ -25,9 +25,21 @@ module PgHaMigrations::SafeStatements
     unsafe_execute("ALTER TYPE #{PG::Connection.quote_ident(name.to_s)} ADD VALUE '#{PG::Connection.escape_string(value)}'")
   end
 
+  def unsafe_rename_enum_value(name, old_value, new_value)
+    if ActiveRecord::Base.connection.postgresql_version < 10_00_00
+      raise PgHaMigrations::InvalidMigrationError, "Renaming an enum value is not supported on Postgres databases before version 10"
+    end
+
+    unsafe_execute("ALTER TYPE #{PG::Connection.quote_ident(name.to_s)} RENAME VALUE '#{PG::Connection.escape_string(old_value)}' TO '#{PG::Connection.escape_string(new_value)}'")
+  end
+
   def safe_add_column(table, column, type, options = {})
-    if options.has_key? :default
-      raise PgHaMigrations::UnsafeMigrationError.new(":default is NOT SAFE! Use safe_change_column_default afterwards then backfill the data to prevent locking the table")
+    if options.has_key?(:default)
+      if ActiveRecord::Base.connection.postgresql_version < 11_00_00
+        raise PgHaMigrations::UnsafeMigrationError.new(":default is NOT SAFE! Use safe_change_column_default afterwards then backfill the data to prevent locking the table")
+      elsif options[:default].is_a?(Proc) || (options[:default].is_a?(String) && !([:string, :text, :binary].include?(type.to_sym) || _type_is_enum(type)))
+        raise PgHaMigrations::UnsafeMigrationError.new(":default is not safe if the default value is volatile. Use safe_change_column_default afterwards then backfill the data to prevent locking the table")
+      end
     end
     if options[:null] == false
       raise PgHaMigrations::UnsafeMigrationError.new(":null => false is NOT SAFE if the table has data! If you _really_ want to do this, use unsafe_make_column_not_nullable")
@@ -45,10 +57,53 @@ module PgHaMigrations::SafeStatements
   def safe_change_column_default(table_name, column_name, default_value)
     column = connection.send(:column_for, table_name, column_name)
 
+    # In 5.2 we have an edge whereby passing in a string literal with an expression
+    # results in confusing behavior because instead of being executed in the database
+    # that expression is turned into a Ruby nil before being sent to the database layer;
+    # this seems to be an expected side effect of a change that was targeted at a use
+    # case unrelated to migrations: https://github.com/rails/rails/commit/7b2dfdeab6e4ef096e4dc1fe313056f08ccf7dc5
+    #
+    # On the other hand, the behavior in 5.1 is also confusing because it quotes the
+    # expression (instead of maintaining the string as-is), which results in Postgres
+    # evaluating the expression once when executing the DDL and setting the default to
+    # the constant result of that evaluation rather than setting the default to the
+    # expression itself.
+    #
+    # Therefore we want to disallow passing in an expression directly as a string and
+    # require the use of a Proc instead with specific quoting rules to determine exact
+    # behavior. It's fairly difficult (without relying on something like the PgQuery gem
+    # which requires native extensions built with the Postgres dev packages installed)
+    # to determine if a string literal represent an expression or just a constant. So
+    # instead of trying to parse the expression, we employ a set of heuristics:
+    # - If the column is text-like or binary, then we can allow anything in the default
+    #   value since a Ruby string there will always coerce directly to the equivalent
+    #   text/binary value rather than being interpreted as a DDL-time expression.
+    # - Custom enum types are a special case: they also are treated like strings by
+    #   Rails, so we want to allow those as-is.
+    # - Otherwise, disallow any Ruby string values and instead require the Ruby object
+    #   type that maps to the column type.
+    #
+    # These heuristics eliminate (virtually?) all ambiguity. In theory there's a
+    # possiblity that some custom object could be coerced-Ruby side into a SQL string
+    # that does something weird here, but that seems an odd enough case that we can
+    # safely ignore it.
     if default_value.present? &&
        !default_value.is_a?(Proc) &&
-       quote_default_expression(default_value, column) == "NULL"
-      raise PgHaMigrations::InvalidMigrationError, "Requested new default value of <#{default_value}>, but that casts to NULL for the type <#{column.type}>. Did you mean to you mean to use a Proc instead?"
+       (
+         connection.quote_default_expression(default_value, column) == "NULL" ||
+         (
+           ![:string, :text, :binary, :enum].include?(column.sql_type_metadata.type) &&
+           default_value.is_a?(String)
+         )
+       )
+      raise PgHaMigrations::InvalidMigrationError, <<~ERROR
+        Setting a default value to an expression using a string literal is ambiguous.
+
+        If you want the default to be:
+        * ...a constant scalar value, use the matching Ruby object type instead of a string if possible (e.g., `DateTime.new(...)`).
+        * ...an expression evaluated at runtime for each row, then pass a Proc that returns the expression string (e.g., `-> { "NOW()" }`).
+        * ...an expression evaluated at migration time, then pass a Proc that returns a quoted expression string (e.g., `-> { "'NOW()'" }`).
+      ERROR
     end
 
     safely_acquire_lock_for_table(table_name) do
@@ -76,7 +131,7 @@ module PgHaMigrations::SafeStatements
     unless options.is_a?(Hash) && options.key?(:name)
       raise ArgumentError, "Expected safe_remove_concurrent_index to be called with arguments (table_name, :name => ...)"
     end
-    unless ActiveRecord::Base.connection.postgresql_version >= 90600
+    unless ActiveRecord::Base.connection.postgresql_version >= 9_06_00
       raise PgHaMigrations::InvalidMigrationError, "Removing an index concurrently is not supported on Postgres 9.1 databases"
     end
     index_size = select_value("SELECT pg_size_pretty(pg_relation_size('#{options[:name]}'))")
@@ -88,6 +143,66 @@ module PgHaMigrations::SafeStatements
     unsafe_execute("SET maintenance_work_mem = '#{PG::Connection.escape_string(gigabytes.to_s)} GB'")
   end
 
+  def safe_add_unvalidated_check_constraint(table, expression, name:)
+    unsafe_add_check_constraint(table, expression, name: name, validate: false)
+  end
+
+  def unsafe_add_check_constraint(table, expression, name:, validate: true)
+    raise ArgumentError, "Expected <name> to be present" unless name.present?
+
+    quoted_table_name = connection.quote_table_name(table)
+    quoted_constraint_name = connection.quote_table_name(name)
+    sql = "ALTER TABLE #{quoted_table_name} ADD CONSTRAINT #{quoted_constraint_name} CHECK (#{expression}) #{validate ? "" : "NOT VALID"}"
+
+    safely_acquire_lock_for_table(table) do
+      say_with_time "add_check_constraint(#{table.inspect}, #{expression.inspect}, name: #{name.inspect}, validate: #{validate.inspect})" do
+        connection.execute(sql)
+      end
+    end
+  end
+
+  def safe_validate_check_constraint(table, name:)
+    raise ArgumentError, "Expected <name> to be present" unless name.present?
+
+    quoted_table_name = connection.quote_table_name(table)
+    quoted_constraint_name = connection.quote_table_name(name)
+    sql = "ALTER TABLE #{quoted_table_name} VALIDATE CONSTRAINT #{quoted_constraint_name}"
+
+    say_with_time "validate_check_constraint(#{table.inspect}, name: #{name.inspect})" do
+      connection.execute(sql)
+    end
+  end
+
+  def safe_rename_constraint(table, from:, to:)
+    raise ArgumentError, "Expected <from> to be present" unless from.present?
+    raise ArgumentError, "Expected <to> to be present" unless to.present?
+
+    quoted_table_name = connection.quote_table_name(table)
+    quoted_constraint_from_name = connection.quote_table_name(from)
+    quoted_constraint_to_name = connection.quote_table_name(to)
+    sql = "ALTER TABLE #{quoted_table_name} RENAME CONSTRAINT #{quoted_constraint_from_name} TO #{quoted_constraint_to_name}"
+
+    safely_acquire_lock_for_table(table) do
+      say_with_time "rename_constraint(#{table.inspect}, from: #{from.inspect}, to: #{to.inspect})" do
+        connection.execute(sql)
+      end
+    end
+  end
+
+  def unsafe_remove_constraint(table, name:)
+    raise ArgumentError, "Expected <name> to be present" unless name.present?
+
+    quoted_table_name = connection.quote_table_name(table)
+    quoted_constraint_name = connection.quote_table_name(name)
+    sql = "ALTER TABLE #{quoted_table_name} DROP CONSTRAINT #{quoted_constraint_name}"
+
+    safely_acquire_lock_for_table(table) do
+      say_with_time "remove_constraint(#{table.inspect}, name: #{name.inspect})" do
+        connection.execute(sql)
+      end
+    end
+  end
+
   def _per_migration_caller
     @_per_migration_caller ||= Kernel.caller
   end
@@ -98,6 +213,18 @@ module PgHaMigrations::SafeStatements
     raise PgHaMigrations::UnsupportedAdapter, "This gem only works with the #{expected_adapter} adapter, found #{actual_adapter} instead" unless actual_adapter == expected_adapter
   end
 
+  def _type_is_enum(type)
+    ActiveRecord::Base.connection.select_values("SELECT typname FROM pg_type JOIN pg_enum ON pg_type.oid = pg_enum.enumtypid").include?(type.to_s)
+  end
+
+  def migrate(direction)
+    if respond_to?(:change)
+      raise PgHaMigrations::UnsupportedMigrationError, "Tracking changes for automated rollback is not supported; use explicit #up instead."
+    end
+
+    super(direction)
+  end
+
   def exec_migration(conn, direction)
     _check_postgres_adapter!
     super(conn, direction)
@@ -123,7 +250,7 @@ module PgHaMigrations::SafeStatements
       end
 
       connection.transaction do
-        adjust_timeout_method = connection.postgresql_version >= 90300 ? :adjust_lock_timeout : :adjust_statement_timeout
+        adjust_timeout_method = connection.postgresql_version >= 9_03_00 ? :adjust_lock_timeout : :adjust_statement_timeout
         begin
           method(adjust_timeout_method).call(PgHaMigrations::LOCK_TIMEOUT_SECONDS) do
             connection.execute("LOCK #{quoted_table_name};")

data/lib/pg_ha_migrations/unsafe_statements.rb

@@ -39,10 +39,10 @@ module PgHaMigrations::UnsafeStatements
   delegate_unsafe_method_to_migration_base_class :change_column
   delegate_unsafe_method_to_migration_base_class :change_column_default
   delegate_unsafe_method_to_migration_base_class :remove_column
-  delegate_unsafe_method_to_migration_base_class :add_index
   delegate_unsafe_method_to_migration_base_class :execute
   delegate_unsafe_method_to_migration_base_class :remove_index
   delegate_unsafe_method_to_migration_base_class :add_foreign_key
+  delegate_unsafe_method_to_migration_base_class :remove_foreign_key
 
   disable_or_delegate_default_method :create_table, ":create_table is NOT SAFE! Use safe_create_table instead"
   disable_or_delegate_default_method :add_column, ":add_column is NOT SAFE! Use safe_add_column instead"
@@ -58,6 +58,7 @@ module PgHaMigrations::UnsafeStatements
   disable_or_delegate_default_method :execute, ":execute is NOT SAFE! Explicitly call :unsafe_execute to proceed", allow_reentry_from_compatibility_module: true
   disable_or_delegate_default_method :remove_index, ":remove_index is NOT SAFE! Use safe_remove_concurrent_index instead for Postgres 9.6 databases; Explicitly call :unsafe_remove_index to proceed on Postgres 9.1"
   disable_or_delegate_default_method :add_foreign_key, ":add_foreign_key is NOT SAFE! Explicitly call :unsafe_add_foreign_key"
+  disable_or_delegate_default_method :remove_foreign_key, ":remove_foreign_key is NOT SAFE! Explicitly call :unsafe_remove_foreign_key"
 
   def unsafe_create_table(table, options={}, &block)
     if options[:force] && !PgHaMigrations.config.allow_force_create_table
@@ -67,6 +68,16 @@ module PgHaMigrations::UnsafeStatements
     execute_ancestor_statement(:create_table, table, options, &block)
   end
 
+  def unsafe_add_index(table, column_names, options = {})
+    if ((ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR >= 2) || ActiveRecord::VERSION::MAJOR > 5) &&
+        column_names.is_a?(String) && /\W/.match?(column_names) && options.key?(:opclass)
+      raise PgHaMigrations::InvalidMigrationError, "ActiveRecord drops the :opclass option when supplying a string containing an expression or list of columns; instead either supply an array of columns or include the opclass in the string for each column"
+    end
+
+    execute_ancestor_statement(:add_index, table, column_names, options)
+  end
+
+
   def execute_ancestor_statement(method_name, *args, &block)
     # Dispatching here is a bit complicated: we need to execute the method
     # belonging to the first member of the inheritance chain (besides

data/lib/pg_ha_migrations/version.rb

@@ -1,3 +1,3 @@
 module PgHaMigrations
-  VERSION = "1.1.0"
+  VERSION = "1.2.4"
 end

data/pg_ha_migrations.gemspec

@@ -29,14 +29,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "pg"
   spec.add_development_dependency "db-query-matchers", "~> 0.9.0"
-  spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "appraisal", "~> 2.2.0"
 
-  spec.add_dependency "rails", ">= 5.0", "< 5.3"
-  spec.add_dependency "relation_to_struct"
+  spec.add_dependency "rails", ">= 5.0", "< 6.1"
+  spec.add_dependency "relation_to_struct", ">= 1.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_ha_migrations
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.4
 platform: ruby
 authors:
 - celeen
@@ -14,22 +14,8 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-05 00:00:00.000000000 Z
+date: 2021-03-05 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -114,6 +100,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -123,7 +123,7 @@ dependencies:
         version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -133,21 +133,21 @@ dependencies:
         version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: relation_to_struct
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.5.1
 description: Enforces DDL/migration safety in Ruby on Rails project with an emphasis
   on explicitly choosing trade-offs and avoiding unnecessary magic.
 email:
@@ -156,11 +156,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".pryrc"
 - ".rspec"
 - ".ruby-version"
 - ".travis.yml"
+- Appraisals
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -168,11 +170,17 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- gemfiles/.bundle/config
+- gemfiles/rails_5.0.gemfile
+- gemfiles/rails_5.1.gemfile
+- gemfiles/rails_5.2.gemfile
+- gemfiles/rails_6.0.gemfile
 - lib/pg_ha_migrations.rb
 - lib/pg_ha_migrations/allowed_versions.rb
 - lib/pg_ha_migrations/blocking_database_transactions.rb
 - lib/pg_ha_migrations/blocking_database_transactions_reporter.rb
 - lib/pg_ha_migrations/dependent_objects_checks.rb
+- lib/pg_ha_migrations/hacks/cleanup_unnecessary_output.rb
 - lib/pg_ha_migrations/hacks/disable_ddl_transaction.rb
 - lib/pg_ha_migrations/railtie.rb
 - lib/pg_ha_migrations/safe_statements.rb
@@ -199,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Enforces DDL/migration safety in Ruby on Rails project with an emphasis on