pg_ha_migrations 1.7.0 → 2.0.0

data/lib/pg_ha_migrations/unsafe_statements.rb

@@ -1,10 +1,6 @@
 module PgHaMigrations::UnsafeStatements
   def self.disable_or_delegate_default_method(method_name, error_message, allow_reentry_from_compatibility_module: false)
     define_method(method_name) do |*args, &block|
-      if PgHaMigrations.config.check_for_dependent_objects
-        disallow_migration_method_if_dependent_objects!(method_name, arguments: args)
-      end
-
       if PgHaMigrations.config.disable_default_migration_methods
         # Most migration methods are only ever called by a migration and
         # therefore aren't re-entrant or callable from another migration
@@ -12,7 +8,7 @@ module PgHaMigrations::UnsafeStatements
         # implementations in `ActiveRecord::Migration::Compatibility` so
         # we have to explicitly handle that case by allowing execution of
         # the original implementation by its original name.
-        unless  allow_reentry_from_compatibility_module && caller[0] =~ /lib\/active_record\/migration\/compatibility.rb/
+        unless allow_reentry_from_compatibility_module && caller[0] =~ /lib\/active_record\/migration\/compatibility.rb/
           raise PgHaMigrations::UnsafeMigrationError, error_message
         end
       end
@@ -22,51 +18,88 @@ module PgHaMigrations::UnsafeStatements
     ruby2_keywords method_name
   end
 
-  def self.delegate_unsafe_method_to_migration_base_class(method_name)
+  def self.delegate_unsafe_method_to_migration_base_class(method_name, with_lock: true)
     define_method("unsafe_#{method_name}") do |*args, &block|
       if PgHaMigrations.config.check_for_dependent_objects
         disallow_migration_method_if_dependent_objects!(method_name, arguments: args)
       end
 
-      execute_ancestor_statement(method_name, *args, &block)
+      if with_lock
+        safely_acquire_lock_for_table(args.first) do
+          execute_ancestor_statement(method_name, *args, &block)
+        end
+      else
+        execute_ancestor_statement(method_name, *args, &block)
+      end
     end
     ruby2_keywords "unsafe_#{method_name}"
   end
 
+  def self.delegate_raw_method_to_migration_base_class(method_name)
+    define_method("raw_#{method_name}") do |*args, &block|
+      execute_ancestor_statement(method_name, *args, &block)
+    end
+    ruby2_keywords "raw_#{method_name}"
+  end
+
+  # Direct dispatch to underlying Rails method as unsafe_<method_name> with dependent object check / safe lock acquisition
+  delegate_unsafe_method_to_migration_base_class :add_check_constraint
   delegate_unsafe_method_to_migration_base_class :add_column
-  delegate_unsafe_method_to_migration_base_class :change_table
-  delegate_unsafe_method_to_migration_base_class :drop_table
-  delegate_unsafe_method_to_migration_base_class :rename_table
-  delegate_unsafe_method_to_migration_base_class :rename_column
   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 :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
-  delegate_unsafe_method_to_migration_base_class :add_check_constraint
+  delegate_unsafe_method_to_migration_base_class :drop_table
+  delegate_unsafe_method_to_migration_base_class :execute, with_lock: false # too generic for locking
   delegate_unsafe_method_to_migration_base_class :remove_check_constraint
+  delegate_unsafe_method_to_migration_base_class :remove_column
+  delegate_unsafe_method_to_migration_base_class :rename_column
+  delegate_unsafe_method_to_migration_base_class :rename_table
 
-  disable_or_delegate_default_method :create_table, ":create_table is NOT SAFE! Use safe_create_table instead"
+  # Direct dispatch to underlying Rails method as raw_<method_name> without dependent object check / locking
+  delegate_raw_method_to_migration_base_class :add_check_constraint
+  delegate_raw_method_to_migration_base_class :add_column
+  delegate_raw_method_to_migration_base_class :add_foreign_key
+  delegate_raw_method_to_migration_base_class :add_index
+  delegate_raw_method_to_migration_base_class :change_column
+  delegate_raw_method_to_migration_base_class :change_column_default
+  delegate_raw_method_to_migration_base_class :change_column_null
+  delegate_raw_method_to_migration_base_class :change_table
+  delegate_raw_method_to_migration_base_class :create_table
+  delegate_raw_method_to_migration_base_class :drop_table
+  delegate_raw_method_to_migration_base_class :execute
+  delegate_raw_method_to_migration_base_class :remove_check_constraint
+  delegate_raw_method_to_migration_base_class :remove_column
+  delegate_raw_method_to_migration_base_class :remove_foreign_key
+  delegate_raw_method_to_migration_base_class :remove_index
+  delegate_raw_method_to_migration_base_class :rename_column
+  delegate_raw_method_to_migration_base_class :rename_table
+
+  # Raises error if disable_default_migration_methods is true
+  # Otherwise, direct dispatch to underlying Rails method without dependent object check / locking
+  disable_or_delegate_default_method :add_check_constraint, ":add_check_constraint is NOT SAFE! Use :safe_add_unvalidated_check_constraint and then :safe_validate_check_constraint instead"
   disable_or_delegate_default_method :add_column, ":add_column is NOT SAFE! Use safe_add_column instead"
-  disable_or_delegate_default_method :change_table, ":change_table is NOT SAFE! Use a combination of safe and explicit unsafe migration methods instead"
-  disable_or_delegate_default_method :drop_table, ":drop_table is NOT SAFE! Explicitly call :unsafe_drop_table to proceed"
-  disable_or_delegate_default_method :rename_table, ":rename_table is NOT SAFE! Explicitly call :unsafe_rename_table to proceed"
-  disable_or_delegate_default_method :rename_column, ":rename_column is NOT SAFE! Explicitly call :unsafe_rename_column to proceed"
+  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 :add_index, ":add_index is NOT SAFE! Use safe_add_concurrent_index instead"
   disable_or_delegate_default_method :change_column, ":change_column is NOT SAFE! Use a combination of safe and explicit unsafe migration methods instead"
   disable_or_delegate_default_method :change_column_default, ":change_column_default is NOT SAFE! Use safe_change_column_default instead"
   disable_or_delegate_default_method :change_column_null, ":change_column_null is NOT (guaranteed to be) SAFE! Either use :safe_make_column_nullable or explicitly call :unsafe_make_column_not_nullable to proceed"
-  disable_or_delegate_default_method :remove_column, ":remove_column is NOT SAFE! Explicitly call :unsafe_remove_column to proceed"
-  disable_or_delegate_default_method :add_index, ":add_index is NOT SAFE! Use safe_add_concurrent_index instead"
+  disable_or_delegate_default_method :change_table, ":change_table is NOT SAFE! Use a combination of safe and explicit unsafe migration methods instead"
+  disable_or_delegate_default_method :create_table, ":create_table is NOT SAFE! Use safe_create_table instead"
+  disable_or_delegate_default_method :drop_table, ":drop_table is NOT SAFE! Explicitly call :unsafe_drop_table to proceed"
   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"
-  disable_or_delegate_default_method :add_check_constraint, ":add_check_constraint is NOT SAFE! Use :safe_add_unvalidated_check_constraint and then :safe_validate_check_constraint instead"
   disable_or_delegate_default_method :remove_check_constraint, ":remove_check_constraint is NOT SAFE! Explicitly call :unsafe_remove_check_constraint to proceed"
+  disable_or_delegate_default_method :remove_column, ":remove_column is NOT SAFE! Explicitly call :unsafe_remove_column to proceed"
+  disable_or_delegate_default_method :remove_foreign_key, ":remove_foreign_key is NOT SAFE! Explicitly call :unsafe_remove_foreign_key"
+  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 :rename_column, ":rename_column is NOT SAFE! Explicitly call :unsafe_rename_column to proceed"
+  disable_or_delegate_default_method :rename_table, ":rename_table is NOT SAFE! Explicitly call :unsafe_rename_table to proceed"
+
+  # Note that unsafe_* methods defined below do not run dependent object checks
+
+  def unsafe_change_table(*args, &block)
+    raise PgHaMigrations::UnsafeMigrationError.new(":change_table is too generic to even allow an unsafe variant. Use a combination of safe and explicit unsafe migration methods instead")
+  end
 
-  def unsafe_create_table(table, options={}, &block)
+  def unsafe_create_table(table, **options, &block)
     if options[:force] && !PgHaMigrations.config.allow_force_create_table
       raise PgHaMigrations::UnsafeMigrationError.new(":force is NOT SAFE! Explicitly call unsafe_drop_table first if you want to recreate an existing table")
     end
@@ -74,13 +107,108 @@ module PgHaMigrations::UnsafeStatements
     execute_ancestor_statement(:create_table, table, **options, &block)
   end
 
-  def unsafe_add_index(table, column_names, options = {})
+  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)
+    validated_table = PgHaMigrations::Table.from_table_name(table)
+
+    validated_index = if options[:name]
+      PgHaMigrations::Index.new(options[:name], validated_table)
+    else
+      PgHaMigrations::Index.from_table_and_columns(validated_table, column_names)
+    end
+
+    options[:name] = validated_index.name
+
+    if options[:algorithm] == :concurrently
+      execute_ancestor_statement(:add_index, table, column_names, **options)
+    else
+      safely_acquire_lock_for_table(table, mode: :share) do
+        execute_ancestor_statement(:add_index, table, column_names, **options)
+      end
+    end
+  end
+
+  def unsafe_remove_index(table, column = nil, **options)
+    if options[:algorithm]== :concurrently
+      execute_ancestor_statement(:remove_index, table, column, **options)
+    else
+      safely_acquire_lock_for_table(table) do
+        execute_ancestor_statement(:remove_index, table, column, **options)
+      end
+    end
+  end
+
+  def unsafe_add_foreign_key(from_table, to_table, **options)
+    safely_acquire_lock_for_table(from_table, to_table, mode: :share_row_exclusive) do
+      execute_ancestor_statement(:add_foreign_key, from_table, to_table, **options)
+    end
+  end
+
+  def unsafe_remove_foreign_key(from_table, to_table = nil, **options)
+    calculated_to_table = options.fetch(:to_table, to_table)
+
+    if calculated_to_table.nil?
+      raise PgHaMigrations::InvalidMigrationError.new("The :to_table positional arg / kwarg is required for lock acquisition")
+    end
+
+    safely_acquire_lock_for_table(from_table, calculated_to_table) do
+      execute_ancestor_statement(:remove_foreign_key, from_table, to_table, **options)
+    end
+  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
+
+    raw_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 unsafe_make_column_not_nullable(table, column, **options) # options arg is only present for backwards compatiblity
+    quoted_table_name = connection.quote_table_name(table)
+    quoted_column_name = connection.quote_column_name(column)
+
+    safely_acquire_lock_for_table(table) do
+      raw_execute("ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quoted_column_name} SET NOT NULL")
+    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 unsafe_partman_update_config(table, **options)
+    invalid_options = options.keys - PgHaMigrations::PARTMAN_UPDATE_CONFIG_OPTIONS
+
+    raise ArgumentError, "Unrecognized argument(s): #{invalid_options}" unless invalid_options.empty?
+
+    PgHaMigrations::PartmanConfig.schema = _quoted_partman_schema
+
+    config = PgHaMigrations::PartmanConfig.find(_fully_qualified_table_name_for_partman(table))
+
+    config.assign_attributes(**options)
+
+    inherit_privileges_changed = config.inherit_privileges_changed?
+
+    say_with_time "partman_update_config(#{table.inspect}, #{options.map { |k,v| "#{k}: #{v.inspect}" }.join(", ")})" do
+      config.save!
+    end
+
+    safe_partman_reapply_privileges(table) if inherit_privileges_changed
   end
 
   ruby2_keywords def execute_ancestor_statement(method_name, *args, &block)

data/lib/pg_ha_migrations/version.rb

@@ -1,3 +1,3 @@
 module PgHaMigrations
-  VERSION = "1.7.0"
+  VERSION = "2.0.0"
 end

data/lib/pg_ha_migrations.rb

@@ -2,6 +2,8 @@ require "pg_ha_migrations/version"
 require "rails"
 require "active_record"
 require "active_record/migration"
+require "active_record/connection_adapters/postgresql/utils"
+require "active_support/core_ext/numeric/bytes"
 require "relation_to_struct"
 require "ruby2_keywords"
 
@@ -17,9 +19,9 @@ module PgHaMigrations
   def self.config
     @config ||= Config.new(
       true,
-      false,
       true,
       false,
+      true,
       true
     )
   end
@@ -30,6 +32,17 @@ module PgHaMigrations
 
   LOCK_TIMEOUT_SECONDS = 5
   LOCK_FAILURE_RETRY_DELAY_MULTLIPLIER = 5
+  SMALL_TABLE_THRESHOLD_BYTES = 10.megabytes
+
+  PARTITION_TYPES = %i[range list hash]
+
+  PARTMAN_UPDATE_CONFIG_OPTIONS = %i[
+    infinite_time_partitions
+    inherit_privileges
+    premake
+    retention
+    retention_keep_table
+  ]
 
   # Safe versus unsafe in this context specifically means the following:
   # - Safe operations will not block for long periods of time.
@@ -52,11 +65,18 @@ module PgHaMigrations
 
   # This gem only supports the PostgreSQL adapter at this time.
   UnsupportedAdapter = Class.new(StandardError)
+
+  # Some methods need to inspect the attributes of a table. In such cases,
+  # this error will be raised if the table does not exist
+  UndefinedTableError = Class.new(StandardError)
 end
 
+require "pg_ha_migrations/constraint"
+require "pg_ha_migrations/relation"
 require "pg_ha_migrations/blocking_database_transactions"
 require "pg_ha_migrations/blocking_database_transactions_reporter"
 require "pg_ha_migrations/partman_config"
+require "pg_ha_migrations/lock_mode"
 require "pg_ha_migrations/unsafe_statements"
 require "pg_ha_migrations/safe_statements"
 require "pg_ha_migrations/dependent_objects_checks"
@@ -64,6 +84,7 @@ 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"
+require "pg_ha_migrations/hacks/add_index_on_only"
 
 module PgHaMigrations::AutoIncluder
   def inherited(klass)

data/pg_ha_migrations.gemspec

@@ -32,12 +32,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "pg"
-  spec.add_development_dependency "db-query-matchers", "~> 0.11.0"
+  spec.add_development_dependency "db-query-matchers", "~> 0.14"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
-  spec.add_development_dependency "appraisal", "~> 2.2.0"
+  spec.add_development_dependency "appraisal", "~> 2.5"
 
-  spec.add_dependency "rails", ">= 6.1", "< 7.1"
+  spec.add_dependency "rails", ">= 7.1", "< 8.1"
   spec.add_dependency "relation_to_struct", ">= 1.5.1"
   spec.add_dependency "ruby2_keywords"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_ha_migrations
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 2.0.0
 platform: ruby
 authors:
 - celeen
@@ -11,10 +11,9 @@ authors:
 - kexline4710
 - mgates
 - redneckbeard
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-10 00:00:00.000000000 Z
+date: 2025-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -64,14 +63,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: '0.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: '0.14'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -106,34 +105,34 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: '2.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: relation_to_struct
   requirement: !ruby/object:Gem::Requirement
@@ -186,17 +185,22 @@ files:
 - bin/setup
 - docker-compose.yml
 - gemfiles/.bundle/config
-- gemfiles/rails_6.1.gemfile
-- gemfiles/rails_7.0.gemfile
+- gemfiles/rails_7.1.gemfile
+- gemfiles/rails_7.2.gemfile
+- gemfiles/rails_8.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/constraint.rb
 - lib/pg_ha_migrations/dependent_objects_checks.rb
+- lib/pg_ha_migrations/hacks/add_index_on_only.rb
 - lib/pg_ha_migrations/hacks/cleanup_unnecessary_output.rb
 - lib/pg_ha_migrations/hacks/disable_ddl_transaction.rb
+- lib/pg_ha_migrations/lock_mode.rb
 - lib/pg_ha_migrations/partman_config.rb
 - lib/pg_ha_migrations/railtie.rb
+- lib/pg_ha_migrations/relation.rb
 - lib/pg_ha_migrations/safe_statements.rb
 - lib/pg_ha_migrations/unsafe_statements.rb
 - lib/pg_ha_migrations/version.rb
@@ -206,7 +210,6 @@ homepage: ''
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -221,8 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Enforces DDL/migration safety in Ruby on Rails project with an emphasis on
   explicitly choosing trade-offs and avoiding unnecessary magic.