pg_ha_migrations 1.5.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5eb93231a1de0f12819682bfe42606bf0cc49813a50b91670107f01eafe8f18
-  data.tar.gz: adcea5f591af66bb790118c562a0cab80dca009421529437d2586e6c0b957f01
+  metadata.gz: 9111677a3084d7b769a43f1c7078822c9ae84420443893f54dc1e228bfa037d1
+  data.tar.gz: 7f1db28ace4c6416980c1f5c3461669f43bd7cb116996c2af7759d48515a8899
 SHA512:
-  metadata.gz: c7c827c5385b13a438a4a2cf1eaa1b7535e54e6d3293f67616849647706ca869a1362db4e102e66802f0930d450a09e3943d365a6b9d7481871c286c3fba1a36
-  data.tar.gz: 334f6c562b0b1288690ff6ec1033beb6676446f4c3a5d708d65de93884e85a65a863d985a37bc02a0c30046d34fbd289f9ac5cca50ada30a9e6d4fcdc0d977ac
+  metadata.gz: 30c567438be90db49faf206696a51176ea397d448913194ac7b2de02349294cced3d3c94fc08e3b5225eb7b1678d997af716de4f3da9cf15491745ae92af2a22
+  data.tar.gz: dba6fa0e40b690a838a2ae26bd48a0cf18b0acda0922a74a14ae8dec295f1c3a48181a11f0ed4bc6cb46f24e9dadd03dcad86ec805c83c00ecd0cf998176cead

data/.github/workflows/ci.yml

@@ -5,39 +5,32 @@ jobs:
     strategy:
       matrix:
         pg:
-          - 9.6
-          - 10
           - 11
           - 12
+          - 13
+          - 14
+          - 15
+        ruby:
+          - 3.0
+          - 3.1
+          - 3.2
         gemfile:
-          - rails_5.0
-          - rails_5.1
-          - rails_5.2
-          - rails_6.0
           - rails_6.1
           - rails_7.0
-    name: PostgreSQL ${{ matrix.pg }}
+    name: PostgreSQL ${{ matrix.pg }} - Ruby ${{ matrix.ruby }} - ${{ matrix.gemfile }}
     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
+      - uses: actions/checkout@v3
+      - name: Build postgres image and start the container
+        run: docker-compose up -d --build
+        env:
+          PGVERSION: ${{ matrix.pg }}
       - name: Setup Ruby using .ruby-version file
         uses: ruby/setup-ruby@v1
         with:
+          ruby-version: ${{ matrix.ruby }}
           bundler-cache: true # runs 'bundle install' and caches installed gems automatically
       - run: bundle exec rake spec

data/.pryrc

@@ -1,9 +1,9 @@
-if defined?(PryByebug)
-  Pry.commands.alias_command 'c', 'continue'
-  Pry.commands.alias_command 's', 'step'
-  Pry.commands.alias_command 'n', 'next'
-  Pry.commands.alias_command 'f', 'finish'
-end
+require "pry-byebug"
+
+Pry.commands.alias_command 'c', 'continue'
+Pry.commands.alias_command 's', 'step'
+Pry.commands.alias_command 'n', 'next'
+Pry.commands.alias_command 'f', 'finish'
 
 # https://github.com/pry/pry/issues/1275#issuecomment-131969510
 # Prevent issue where text input does not display on screen in container after typing Ctrl-C in a pry repl

data/.ruby-version

@@ -1 +1 @@
-ruby-2.7
+ruby-3.0

data/Appraisals

@@ -1,23 +1,7 @@
-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
-
 appraise "rails-6.1" do
   gem "rails", "6.1.0"
 end
 
 appraise "rails-7.0" do
-  gem "rails", "7.0.0"
+  gem "rails", "7.0.1"
 end

data/Dockerfile

@@ -0,0 +1,11 @@
+ARG PGVERSION
+
+FROM postgres:$PGVERSION-bullseye
+
+RUN apt-get update && apt-get install -y curl ca-certificates gnupg lsb-release
+
+RUN curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | tee /etc/apt/trusted.gpg.d/apt.postgresql.org.gpg >/dev/null
+
+RUN echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list
+
+RUN apt update && apt-get install -y postgresql-$PG_MAJOR-partman

data/README.md

@@ -1,8 +1,8 @@
 # PgHaMigrations
 
-[![Build Status](https://travis-ci.org/braintree/pg_ha_migrations.svg?branch=master)](https://travis-ci.org/braintree/pg_ha_migrations/)
+[![Build Status](https://github.com/braintree/pg_ha_migrations/actions/workflows/ci.yml/badge.svg)](https://github.com/braintree/pg_ha_migrations/actions/workflows/ci.yml?query=branch%3Amaster+)
 
-We've documented our learned best practices for applying schema changes without downtime in the post [PostgreSQL at Scale: Database Schema Changes Without Downtime](https://medium.com/braintree-product-technology/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680) on the [Braintree Product and Technology Blog](https://medium.com/braintree-product-technology). Many of the approaches we take and choices we've made are explained in much greater depth there than in this README.
+We've documented our learned best practices for applying schema changes without downtime in the post [PostgreSQL at Scale: Database Schema Changes Without Downtime](https://medium.com/paypal-tech/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680) on the [PayPal Technology Blog](https://medium.com/paypal-tech). Many of the approaches we take and choices we've made are explained in much greater depth there than in this README.
 
 Internally we apply those best practices to our Rails applications through this gem which updates ActiveRecord migrations to clearly delineate safe and unsafe DDL as well as provide safe alternatives where possible.
 
@@ -34,7 +34,7 @@ Or install it yourself as:
 
 ### Rollback
 
-Because we require that ["Rollback strategies do not involve reverting the database schema to its previous version"](https://medium.com/braintree-product-technology/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680#360a), PgHaMigrations does not support ActiveRecord's automatic migration rollback capability.
+Because we require that ["Rollback strategies do not involve reverting the database schema to its previous version"](https://medium.com/paypal-tech/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680#360a), PgHaMigrations does not support ActiveRecord's automatic migration rollback capability.
 
 Instead we write all of our migrations with only an `def up` method like:
 
@@ -68,7 +68,7 @@ When `unsafe_*` migration methods support checks of this type you can bypass the
 
 Similarly we believe the `force: true` option to ActiveRecord's `create_table` method is always unsafe, and therefore we disallow it even when calling `unsafe_create_table`. This option won't be enabled by default until 2.0, but you can opt-in by setting `config.allow_force_create_table = false` [in your configuration initializer](#configuration).
 
-[Running multiple DDL statements inside a transaction acquires exclusive locks on all of the modified objects](https://medium.com/braintree-product-technology/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680#cc22). For that reason, this gem [disables DDL transactions](./lib/pg_ha_migrations.rb:8) by default. You can change this by resetting `ActiveRecord::Migration.disable_ddl_transaction` in your application.
+[Running multiple DDL statements inside a transaction acquires exclusive locks on all of the modified objects](https://medium.com/paypal-tech/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680#cc22). For that reason, this gem [disables DDL transactions](./lib/pg_ha_migrations.rb:8) by default. You can change this by resetting `ActiveRecord::Migration.disable_ddl_transaction` in your application.
 
 The following functionality is currently unsupported:
 
@@ -220,6 +220,169 @@ Drop any (not just `CHECK`) constraint.
 unsafe_remove_constraint :table, name: :constraint_table_on_column_like_example
 ```
 
+#### safe\_create\_partitioned\_table
+
+Safely create a new partitioned table using [declaritive partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE).
+
+```ruby
+# list partitioned table using single column as partition key
+safe_create_partitioned_table :table, type: :list, partition_key: :example_column do |t|
+  t.text :example_column, null: false
+end
+
+# range partitioned table using multiple columns as partition key
+safe_create_partitioned_table :table, type: :range, partition_key: [:example_column_a, :example_column_b] do |t|
+  t.integer :example_column_a, null: false
+  t.integer :example_column_b, null: false
+end
+
+# hash partitioned table using expression as partition key
+safe_create_partitioned_table :table, :type: :hash, partition_key: ->{ "(example_column::date)" } do |t|
+  t.datetime :example_column, null: false
+end
+```
+
+The identifier column type is `bigserial` by default. This can be overridden, as you would in `safe_create_table`, by setting the `id` argument:
+
+```ruby
+safe_create_partitioned_table :table, id: :serial, type: :range, partition_key: :example_column do |t|
+  t.date :example_column, null: false
+end
+```
+
+In PostgreSQL 11+, primary key constraints are supported on partitioned tables given the partition key is included. On supported versions, the primary key is inferred by default (see [available options](#available-options)). This functionality can be overridden by setting the `infer_primary_key` argument.
+
+```ruby
+# primary key will be (id, example_column)
+safe_create_partitioned_table :table, type: :range, partition_key: :example_column do |t|
+  t.date :example_column, null: false
+end
+
+# primary key will not be created
+safe_create_partitioned_table :table, type: :range, partition_key: :example_column, infer_primary_key: false do |t|
+  t.date :example_column, null: false
+end
+```
+
+#### safe\_partman\_create\_parent
+
+Safely configure a partitioned table to be managed by [pg\_partman](https://github.com/pgpartman/pg_partman).
+
+This method calls the [create\_parent](https://github.com/pgpartman/pg_partman/blob/master/doc/pg_partman.md#creation-functions) partman function with some reasonable defaults and a subset of user-defined overrides.
+
+The first (and only) positional argument maps to `p_parent_table` in the `create_parent` function.
+
+The rest are keyword args with the following mappings:
+
+- `partition_key` -> `p_control`. Required: `true`
+- `interval` -> `p_interval`. Required: `true`
+- `template_table` -> `p_template_table`. Required: `false`. Partman will create a template table if not defined.
+- `premake` -> `p_premake`. Required: `false`. Partman defaults to `4`.
+- `start_partition` -> `p_start_partition`. Required: `false`. Partman defaults to the current timestamp.
+
+Note that we have chosen to require PostgreSQL 11+ and hardcode `p_type` to `native` for simplicity, as previous PostgreSQL versions are end-of-life.
+
+Additionally, this method allows you to configure a subset of attributes on the record stored in the [part\_config](https://github.com/pgpartman/pg_partman/blob/master/doc/pg_partman.md#tables) table.
+These options are delegated to the `unsafe_partman_update_config` method to update the record:
+
+- `infinite_time_partitions`. Partman defaults this to `false` but we default to `true`
+- `inherit_privileges`. Partman defaults this to `false` but we default to `true`
+- `retention`. Partman defaults this to `null`
+- `retention_keep_table`. Partman defaults this to `true`
+
+With only the required args:
+
+```ruby
+safe_create_partitioned_table :table, type: :range, partition_key: :created_at do |t|
+  t.timestamps null: false
+end
+
+safe_partman_create_parent :table, partition_key: :created_at, interval: "weekly"
+```
+
+With custom overrides:
+
+```ruby
+safe_create_partitioned_table :table, type: :range, partition_key: :created_at do |t|
+  t.timestamps null: false
+  t.text :some_column
+end
+
+# Partman will reference the template table to create unique indexes on child tables
+safe_create_table :table_template, id: false do |t|
+  t.text :some_column, index: {unique: true}
+end
+
+safe_partman_create_parent :table,
+  partition_key: :created_at,
+  interval: "weekly",
+  template_table: :table_template,
+  premake: 10,
+  start_partition: Time.current + 1.month,
+  infinite_time_partitions: false,
+  inherit_privileges: false
+```
+
+#### unsafe\_partman\_create\_parent
+
+We have chosen to flag the use of `retention` and `retention_keep_table` as an unsafe operation.
+While we recognize that these options are useful, we think they fit in the same category as `drop_table` and `rename_table`, and are therefore unsafe from an application perspective.
+If you wish to define these options, you must use this method.
+
+```ruby
+safe_create_partitioned_table :table, type: :range, partition_key: :created_at do |t|
+  t.timestamps null: false
+end
+
+unsafe_partman_create_parent :table,
+  partition_key: :created_at,
+  interval: "weekly",
+  retention: "60 days",
+  retention_keep_table: false
+```
+
+#### safe\_partman\_update\_config
+
+There are some partitioning options that cannot be set in the call to `create_parent` and are only available in the `part_config` table.
+As mentioned previously, you can specify these args in the call to `safe_partman_create_parent` or `unsafe_partman_create_parent` which will be delegated to this method.
+Calling this method directly will be useful if you need to modify your partitioned table after the fact.
+
+Allowed keyword args:
+
+- `infinite_time_partitions`
+- `inherit_privileges`
+- `premake`
+- `retention`
+- `retention_keep_table`
+
+Note that we detect if the value of `inherit_privileges` is changing and will automatically call `safe_partman_reapply_privileges` to ensure permissions are propagated to existing child partitions.
+
+```ruby
+safe_partman_update_config :table,
+  infinite_time_partitions: false,
+  inherit_privileges: false,
+  premake: 10
+```
+
+#### unsafe\_partman\_update\_config
+
+As with creating a partman parent table, we have chosen to flag the use of `retention` and `retention_keep_table` as an unsafe operation.
+If you wish to define these options, you must use this method.
+
+```ruby
+unsafe_partman_update_config :table,
+  retention: "60 days",
+  retention_keep_table: false
+```
+
+#### safe\_partman\_reapply\_privileges
+
+If your partitioned table is configured with `inherit_privileges` set to `true`, use this method after granting new roles / privileges on the parent table to ensure permissions are propagated to existing child partitions.
+
+```ruby
+safe_partman_reapply_privileges :table
+```
+
 ### Utilities
 
 #### safely\_acquire\_lock\_for\_table
@@ -274,8 +437,9 @@ end
 
 - `disable_default_migration_methods`: If true, the default implementations of DDL changes in `ActiveRecord::Migration` and the PostgreSQL adapter will be overridden by implementations that raise a `PgHaMigrations::UnsafeMigrationError`. Default: `true`
 - `check_for_dependent_objects`: If true, some `unsafe_*` migration methods will raise a `PgHaMigrations::UnsafeMigrationError` if any dependent objects exist. Default: `false`
-- `prefer_single_step_column_addition_with_default`: If `true`, raise an error when adding a column and separately setting a constant default value for that column in the same migration. Default: `false`
-- 'allow_force_create_table`: If false, the `force: true` option to ActiveRecord's `create_table` method is disallowed. Default: `true`
+- `prefer_single_step_column_addition_with_default`: If true, raise an error when adding a column and separately setting a constant default value for that column in the same migration. Default: `false`
+- `allow_force_create_table`: If false, the `force: true` option to ActiveRecord's `create_table` method is disallowed. Default: `true`
+- `infer_primary_key_on_partitioned_tables`: If true, the primary key for partitioned tables will be inferred on PostgreSQL 11+ databases (identifier column + partition key columns). Default: `true`
 
 ### Rake Tasks
 
@@ -305,7 +469,7 @@ Running tests will automatically create a test database in the locally running P
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 
-To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To release a new version, update the version number in `version.rb`, commit the change, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 Note: if while releasing the gem you get the error ``Your rubygems.org credentials aren't set. Run `gem push` to set them.`` you can more simply run `gem signin`.
 

data/bin/setup

@@ -2,14 +2,11 @@
 set -euo pipefail
 IFS=$'\n\t'
 set -vx
-export PGPASSWORD="${PGPASSWORD:-postgres}"
-PGVERSION="${PGVERSION:-13}"
-
 
 bundle install
 bundle exec appraisal install
 
 # Do any other automated setup that you need to do here
 
-# Launch a blank postgres image for testing
-docker run -d -p 127.0.0.1:5432:5432 -e POSTGRES_PASSWORD="${PGPASSWORD}" postgres:${PGVERSION}
+# Launch a blank postgres image with partman for testing
+docker-compose up -d --build

data/docker-compose.yml

@@ -0,0 +1,11 @@
+version: "3.3"
+services:
+  db:
+    build:
+      context: .
+      args:
+        - PGVERSION=${PGVERSION:-15}
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_PASSWORD=${PGPASSWORD:-postgres}

data/gemfiles/rails_7.0.gemfile

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "rails", "7.0.0"
+gem "rails", "7.0.1"
 
 gemspec path: "../"

data/lib/pg_ha_migrations/partman_config.rb

@@ -0,0 +1,11 @@
+# This is an internal class that is not meant to be used directly
+class PgHaMigrations::PartmanConfig < ActiveRecord::Base
+  self.primary_key = :parent_table
+
+  # This method is called by unsafe_partman_update_config to set the fully
+  # qualified table name, as partman is often installed in a schema that
+  # is not included the application's search path
+  def self.schema=(schema)
+    self.table_name = "#{schema}.part_config"
+  end
+end

data/lib/pg_ha_migrations/safe_statements.rb

@@ -1,4 +1,14 @@
 module PgHaMigrations::SafeStatements
+  PARTITION_TYPES = %i[range list hash]
+
+  PARTMAN_UPDATE_CONFIG_OPTIONS = %i[
+    infinite_time_partitions
+    inherit_privileges
+    premake
+    retention
+    retention_keep_table
+  ]
+
   def safe_added_columns_without_default_value
     @safe_added_columns_without_default_value ||= []
   end
@@ -65,7 +75,7 @@ module PgHaMigrations::SafeStatements
 
   def unsafe_add_column(table, column, type, options = {})
     safely_acquire_lock_for_table(table) do
-      super(table, column, type, options)
+      super(table, column, type, **options)
     end
   end
 
@@ -145,7 +155,7 @@ module PgHaMigrations::SafeStatements
   end
 
   def safe_add_concurrent_index(table, columns, options={})
-    unsafe_add_index(table, columns, options.merge(:algorithm => :concurrently))
+    unsafe_add_index(table, columns, **options.merge(:algorithm => :concurrently))
   end
 
   def safe_remove_concurrent_index(table, options={})
@@ -157,7 +167,7 @@ module PgHaMigrations::SafeStatements
     end
     index_size = select_value("SELECT pg_size_pretty(pg_relation_size('#{options[:name]}'))")
     say "Preparing to drop index #{options[:name]} which is #{index_size} on disk..."
-    unsafe_remove_index(table, options.merge(:algorithm => :concurrently))
+    unsafe_remove_index(table, **options.merge(:algorithm => :concurrently))
   end
 
   def safe_set_maintenance_work_mem_gb(gigabytes)
@@ -168,20 +178,6 @@ module PgHaMigrations::SafeStatements
     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?
 
@@ -224,6 +220,222 @@ module PgHaMigrations::SafeStatements
     end
   end
 
+  def safe_create_partitioned_table(table, partition_key:, type:, infer_primary_key: nil, **options, &block)
+    raise ArgumentError, "Expected <partition_key> to be present" unless partition_key.present?
+
+    unless PARTITION_TYPES.include?(type)
+      raise ArgumentError, "Expected <type> to be symbol in #{PARTITION_TYPES} but received #{type.inspect}"
+    end
+
+    if ActiveRecord::Base.connection.postgresql_version < 10_00_00
+      raise PgHaMigrations::InvalidMigrationError, "Native partitioning not supported on Postgres databases before version 10"
+    end
+
+    if type == :hash && ActiveRecord::Base.connection.postgresql_version < 11_00_00
+      raise PgHaMigrations::InvalidMigrationError, "Hash partitioning not supported on Postgres databases before version 11"
+    end
+
+    if infer_primary_key.nil?
+      infer_primary_key = PgHaMigrations.config.infer_primary_key_on_partitioned_tables
+    end
+
+    # Newer versions of Rails will set the primary key column to the type :primary_key.
+    # This performs some extra logic that we can't easily undo which causes problems when
+    # trying to inject the partition key into the PK. Now, it would be nice to lookup the
+    # default primary key type instead of simply using :bigserial, but it doesn't appear
+    # that we have access to the Rails configuration from within our migrations.
+    if options[:id].nil? || options[:id] == :primary_key
+      options[:id] = :bigserial
+    end
+
+    quoted_partition_key = if partition_key.is_a?(Proc)
+      # Lambda syntax, like in other migration methods, implies an expression that
+      # cannot be easily sanitized.
+      #
+      # e.g ->{ "(created_at::date)" }
+      partition_key.call.to_s
+    else
+      # Otherwise, assume key is a column name or array of column names
+      Array.wrap(partition_key).map { |col| connection.quote_column_name(col) }.join(",")
+    end
+
+    options[:options] = "PARTITION BY #{type.upcase} (#{quoted_partition_key})"
+
+    safe_create_table(table, options) do |td|
+      block.call(td) if block
+
+      next unless options[:id]
+
+      pk_columns = td.columns.each_with_object([]) do |col, arr|
+        next unless col.options[:primary_key]
+
+        col.options[:primary_key] = false
+
+        arr << col.name
+      end
+
+      if infer_primary_key && !partition_key.is_a?(Proc) && ActiveRecord::Base.connection.postgresql_version >= 11_00_00
+        td.primary_keys(pk_columns.concat(Array.wrap(partition_key)).map(&:to_s).uniq)
+      end
+    end
+  end
+
+  def safe_partman_create_parent(table, **options)
+    if options[:retention].present? || options[:retention_keep_table] == false
+      raise PgHaMigrations::UnsafeMigrationError.new(":retention and/or :retention_keep_table => false can potentially result in data loss if misconfigured. Please use unsafe_partman_create_parent if you want to set these options")
+    end
+
+    unsafe_partman_create_parent(table, **options)
+  end
+
+  def unsafe_partman_create_parent(
+    table,
+    partition_key:,
+    interval:,
+    infinite_time_partitions: true,
+    inherit_privileges: true,
+    premake: nil,
+    start_partition: nil,
+    template_table: nil,
+    retention: nil,
+    retention_keep_table: nil
+  )
+    raise ArgumentError, "Expected <partition_key> to be present" unless partition_key.present?
+    raise ArgumentError, "Expected <interval> to be present" unless interval.present?
+
+    if ActiveRecord::Base.connection.postgresql_version < 11_00_00
+      raise PgHaMigrations::InvalidMigrationError, "Native partitioning with partman not supported on Postgres databases before version 11"
+    end
+
+    formatted_start_partition = nil
+
+    if start_partition.present?
+      if !start_partition.is_a?(Date) && !start_partition.is_a?(Time) && !start_partition.is_a?(DateTime)
+        raise PgHaMigrations::InvalidMigrationError, "Expected <start_partition> to be Date, Time, or DateTime object but received #{start_partition.class}"
+      end
+
+      formatted_start_partition = if start_partition.respond_to?(:to_fs)
+        start_partition.to_fs(:db)
+      else
+        start_partition.to_s(:db)
+      end
+    end
+
+    create_parent_options = {
+      parent_table: _fully_qualified_table_name_for_partman(table),
+      template_table: template_table ? _fully_qualified_table_name_for_partman(template_table) : nil,
+      control: partition_key,
+      type: "native",
+      interval: interval,
+      premake: premake,
+      start_partition: formatted_start_partition,
+    }.compact
+
+    create_parent_sql = create_parent_options.map { |k, v| "p_#{k} := #{connection.quote(v)}" }.join(", ")
+
+    log_message = "partman_create_parent(#{table.inspect}, " \
+      "partition_key: #{partition_key.inspect}, " \
+      "interval: #{interval.inspect}, " \
+      "premake: #{premake.inspect}, " \
+      "start_partition: #{start_partition.inspect}, " \
+      "template_table: #{template_table.inspect})"
+
+    say_with_time(log_message) do
+      connection.execute("SELECT #{_quoted_partman_schema}.create_parent(#{create_parent_sql})")
+    end
+
+    update_config_options = {
+      infinite_time_partitions: infinite_time_partitions,
+      inherit_privileges: inherit_privileges,
+      retention: retention,
+      retention_keep_table: retention_keep_table,
+    }.compact
+
+    unsafe_partman_update_config(create_parent_options[:parent_table], **update_config_options)
+  end
+
+  def safe_partman_update_config(table, **options)
+    if options[:retention].present? || options[:retention_keep_table] == false
+      raise PgHaMigrations::UnsafeMigrationError.new(":retention and/or :retention_keep_table => false can potentially result in data loss if misconfigured. Please use unsafe_partman_update_config if you want to set these options")
+    end
+
+    unsafe_partman_update_config(table, **options)
+  end
+
+  def unsafe_partman_update_config(table, **options)
+    invalid_options = options.keys - 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
+
+  def safe_partman_reapply_privileges(table)
+    say_with_time "partman_reapply_privileges(#{table.inspect})" do
+      connection.execute("SELECT #{_quoted_partman_schema}.reapply_privileges('#{_fully_qualified_table_name_for_partman(table)}')")
+    end
+  end
+
+  def _quoted_partman_schema
+    schema = connection.select_value(<<~SQL)
+      SELECT nspname
+      FROM pg_namespace JOIN pg_extension
+        ON pg_namespace.oid = pg_extension.extnamespace
+      WHERE pg_extension.extname = 'pg_partman'
+    SQL
+
+    raise PgHaMigrations::InvalidMigrationError, "The pg_partman extension is not installed" unless schema.present?
+
+    connection.quote_schema_name(schema)
+  end
+
+  def _fully_qualified_table_name_for_partman(table)
+    identifiers = table.to_s.split(".")
+
+    raise PgHaMigrations::InvalidMigrationError, "Expected table to be in the format <table> or <schema>.<table> but received #{table}" if identifiers.size > 2
+
+    identifiers.each { |identifier| _validate_partman_identifier(identifier) }
+
+    schema_conditional = if identifiers.size > 1
+      "'#{identifiers.first}'"
+    else
+      "ANY (current_schemas(false))"
+    end
+
+    schema = connection.select_value(<<~SQL)
+      SELECT schemaname
+      FROM pg_tables
+      WHERE tablename = '#{identifiers.last}' AND schemaname = #{schema_conditional}
+      ORDER BY array_position(current_schemas(false), schemaname)
+      LIMIT 1
+    SQL
+
+    raise PgHaMigrations::InvalidMigrationError, "Could not find table #{table}" unless schema.present?
+
+    _validate_partman_identifier(schema)
+
+    # Quoting is unneeded since _validate_partman_identifier ensures the schema / table use standard naming conventions
+    "#{schema}.#{identifiers.last}"
+  end
+
+  def _validate_partman_identifier(identifier)
+    if identifier.to_s !~ /^[a-z_][a-z_\d]*$/
+      raise PgHaMigrations::InvalidMigrationError, "Partman requires schema / table names to be lowercase with underscores"
+    end
+  end
+
   def _per_migration_caller
     @_per_migration_caller ||= Kernel.caller
   end

data/lib/pg_ha_migrations/unsafe_statements.rb

@@ -19,6 +19,7 @@ module PgHaMigrations::UnsafeStatements
 
       execute_ancestor_statement(method_name, *args, &block)
     end
+    ruby2_keywords method_name
   end
 
   def self.delegate_unsafe_method_to_migration_base_class(method_name)
@@ -29,6 +30,7 @@ module PgHaMigrations::UnsafeStatements
 
       execute_ancestor_statement(method_name, *args, &block)
     end
+    ruby2_keywords "unsafe_#{method_name}"
   end
 
   delegate_unsafe_method_to_migration_base_class :add_column
@@ -43,6 +45,8 @@ module PgHaMigrations::UnsafeStatements
   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 :remove_check_constraint
 
   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"
@@ -59,13 +63,15 @@ module PgHaMigrations::UnsafeStatements
   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"
 
   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
 
-    execute_ancestor_statement(:create_table, table, options, &block)
+    execute_ancestor_statement(:create_table, table, **options, &block)
   end
 
   def unsafe_add_index(table, column_names, options = {})
@@ -74,11 +80,10 @@ module PgHaMigrations::UnsafeStatements
       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)
+    execute_ancestor_statement(:add_index, table, column_names, **options)
   end
 
-
-  def execute_ancestor_statement(method_name, *args, &block)
+  ruby2_keywords 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
     # UnsafeStatements). If don't find the method in the inheritance chain,

data/lib/pg_ha_migrations/version.rb

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

data/lib/pg_ha_migrations.rb

@@ -3,13 +3,15 @@ require "rails"
 require "active_record"
 require "active_record/migration"
 require "relation_to_struct"
+require "ruby2_keywords"
 
 module PgHaMigrations
   Config = Struct.new(
     :disable_default_migration_methods,
     :check_for_dependent_objects,
     :allow_force_create_table,
-    :prefer_single_step_column_addition_with_default
+    :prefer_single_step_column_addition_with_default,
+    :infer_primary_key_on_partitioned_tables,
   )
 
   def self.config
@@ -17,7 +19,8 @@ module PgHaMigrations
       true,
       false,
       true,
-      false
+      false,
+      true
     )
   end
 
@@ -41,7 +44,7 @@ module PgHaMigrations
   # raise this error. For example, adding a column without a default and
   # then setting its default in a second action in a single migration
   # isn't our documented best practice and will raise this error.
-  BestPracticeError = Class.new(Exception)
+  BestPracticeError = Class.new(StandardError)
 
   # Unsupported migrations use ActiveRecord::Migration features that
   # we don't support, and therefore will likely have unexpected behavior.
@@ -53,6 +56,7 @@ end
 
 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/unsafe_statements"
 require "pg_ha_migrations/safe_statements"
 require "pg_ha_migrations/dependent_objects_checks"

data/pg_ha_migrations.gemspec

@@ -37,6 +37,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "appraisal", "~> 2.2.0"
 
-  spec.add_dependency "rails", ">= 5.0", "< 7.1"
+  spec.add_dependency "rails", ">= 6.1", "< 7.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.5.0
+  version: 1.7.0
 platform: ruby
 authors:
 - celeen
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-09 00:00:00.000000000 Z
+date: 2023-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -120,7 +120,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '7.1'
@@ -130,7 +130,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '7.1'
@@ -148,6 +148,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: ruby2_keywords
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Enforces DDL/migration safety in Ruby on Rails project with an emphasis
   on explicitly choosing trade-offs and avoiding unnecessary magic.
 email:
@@ -163,17 +177,15 @@ files:
 - ".ruby-version"
 - Appraisals
 - CODE_OF_CONDUCT.md
+- Dockerfile
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- docker-compose.yml
 - gemfiles/.bundle/config
-- gemfiles/rails_5.0.gemfile
-- gemfiles/rails_5.1.gemfile
-- gemfiles/rails_5.2.gemfile
-- gemfiles/rails_6.0.gemfile
 - gemfiles/rails_6.1.gemfile
 - gemfiles/rails_7.0.gemfile
 - lib/pg_ha_migrations.rb
@@ -183,6 +195,7 @@ files:
 - 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/partman_config.rb
 - lib/pg_ha_migrations/railtie.rb
 - lib/pg_ha_migrations/safe_statements.rb
 - lib/pg_ha_migrations/unsafe_statements.rb
@@ -208,7 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Enforces DDL/migration safety in Ruby on Rails project with an emphasis on

data/gemfiles/rails_5.0.gemfile

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

data/gemfiles/rails_5.1.gemfile

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

data/gemfiles/rails_5.2.gemfile

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

data/gemfiles/rails_6.0.gemfile

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