pg_ha_migrations 1.6.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6962b68069791fd1de1da3dd1f8a3bb34438faf217023fdcc05d792eb345a666
-  data.tar.gz: 450e7710be2bac4d25e77dabfb7eff9048f9321ebcf90a428a6125edab848f69
+  metadata.gz: 6858f02b9a874bbaf79865c789a490c9aa1140240537d0eded8f48486c6348f3
+  data.tar.gz: 733394b7f83821f71821816777765d982d1580761522e0751534d3e3c62f598b
 SHA512:
-  metadata.gz: 7467eee266a3c9f49faa84cc771ae35d601b25cc38cfe097b5d696e01dfd317ed1a6b5e67e8a053f80cc262bedf2f3b204dbb4b98732d09688485371613025f1
-  data.tar.gz: 63d05306b246ff151d0849967bd71a5457f94d1ac968cc155fcd58e5b359c868a4888167e43fd5775e7bec3bfc8dab9eb71341b80971b4ffd03ed0a189f8ff83
+  metadata.gz: 55f3f8e3730fc11183e71cbf6ba9d32dabf1c8b0ec532da6861b47d045cffb348184350831f564999ecee22b601931ab577ca20f8c4e831e0d4b776babe21a58
+  data.tar.gz: e260ebe93cafba7f3119c41bd2594a797293713f95d072378dbc5733f176d86ce8a93c8a24b53b6fbb9ec77756f4db9ab5fdb92f6080de6ac0fb56e158e5b5d3

data/.github/workflows/ci.yml

@@ -5,88 +5,31 @@ jobs:
     strategy:
       matrix:
         pg:
-          - 9.6
-          - 10
           - 11
           - 12
+          - 13
+          - 14
+          - 15
+          - 16
         ruby:
-          - 2.7
+          - "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
-        include:
-          - gemfile: rails_6.1
-            ruby: 3.0
-            pg: 9.6
-          - gemfile: rails_6.1
-            ruby: 3.0
-            pg: 10
-          - gemfile: rails_6.1
-            ruby: 3.0
-            pg: 11
-          - gemfile: rails_6.1
-            ruby: 3.0
-            pg: 12
-          - gemfile: rails_6.1
-            ruby: 3.1
-            pg: 9.6
-          - gemfile: rails_6.1
-            ruby: 3.1
-            pg: 10
-          - gemfile: rails_6.1
-            ruby: 3.1
-            pg: 11
-          - gemfile: rails_6.1
-            ruby: 3.1
-            pg: 12
-          - gemfile: rails_7.0
-            ruby: 3.0
-            pg: 9.6
-          - gemfile: rails_7.0
-            ruby: 3.0
-            pg: 10
-          - gemfile: rails_7.0
-            ruby: 3.0
-            pg: 11
-          - gemfile: rails_7.0
-            ruby: 3.0
-            pg: 12
-          - gemfile: rails_7.0
-            ruby: 3.1
-            pg: 9.6
-          - gemfile: rails_7.0
-            ruby: 3.1
-            pg: 10
-          - gemfile: rails_7.0
-            ruby: 3.1
-            pg: 11
-          - gemfile: rails_7.0
-            ruby: 3.1
-            pg: 12
-    name: PostgreSQL ${{ matrix.pg }}
+          - rails_7.1
+    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:

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,11 @@
-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"
+  gem "rails", "6.1.7.6"
 end
 
 appraise "rails-7.0" do
-  gem "rails", "7.0.0"
+  gem "rails", "7.0.8"
+end
+
+appraise "rails-7.1" do
+  gem "rails", "7.1.0"
 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 https://apt-archive.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg-archive main" > /etc/apt/sources.list.d/pgdg.list
+
+RUN apt update && apt-get install -y postgresql-$PG_MAJOR-partman=4.7.4-2.pgdg110+1

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/hacks/disable_ddl_transaction.rb) by default. You can change this by resetting `ActiveRecord::Migration.disable_ddl_transaction` in your application.
 
 The following functionality is currently unsupported:
 
@@ -76,6 +76,11 @@ The following functionality is currently unsupported:
 - Generators
 - schema.rb
 
+Compatibility notes:
+
+- While some features may work with other versions, this gem is currently tested against PostgreSQL 11+ and Partman 4.x
+- There is a [bug](https://github.com/rails/rails/pull/41490) in early versions of Rails 6.1 when using `algorithm: :concurrently`. To add / remove indexes concurrently, please upgrade to at least Rails 6.1.4.
+
 #### safe\_create\_table
 
 Safely creates a new table.
@@ -166,6 +171,14 @@ Unsafely make a column not nullable.
 unsafe_make_column_not_nullable :table, :column
 ```
 
+#### safe\_add\_index\_on\_empty\_table
+
+Safely add an index on a table with zero rows. This will raise an error if the table contains data.
+
+```ruby
+safe_add_index_on_empty_table :table, :column
+```
+
 #### safe\_add\_concurrent\_index
 
 Add an index concurrently.
@@ -188,6 +201,41 @@ Safely remove an index. Migrations that contain this statement must also include
 safe_remove_concurrent_index :table, :name => :index_name
 ```
 
+#### safe\_add\_concurrent\_partitioned\_index
+
+Add an index to a natively partitioned table concurrently, as described in the [table partitioning docs](https://www.postgresql.org/docs/current/ddl-partitioning.html):
+
+> To avoid long lock times, it is possible to use `CREATE INDEX ON ONLY` the partitioned table; such an index is marked invalid, and the partitions do not get the index applied automatically.
+> The indexes on partitions can be created individually using `CONCURRENTLY`, and then attached to the index on the parent using `ALTER INDEX .. ATTACH PARTITION`.
+> Once indexes for all partitions are attached to the parent index, the parent index is marked valid automatically.
+
+```ruby
+# Assuming this table has partitions child1 and child2, the following indexes will be created:
+#   - index_partitioned_table_on_column
+#   - index_child1_on_column (attached to index_partitioned_table_on_column)
+#   - index_child2_on_column (attached to index_partitioned_table_on_column)
+safe_add_concurrent_partitioned_index :partitioned_table, :column
+```
+
+Add a composite index using the `hash` index type with custom name for the parent index when the parent table contains sub-partitions.
+
+```ruby
+# Assuming this table has partitions child1 and child2, and child1 has sub-partitions sub1 and sub2,
+# the following indexes will be created:
+#   - custom_name_idx
+#   - index_child1_on_column1_column2 (attached to custom_name_idx)
+#   - index_sub1_on_column1_column2 (attached to index_child1_on_column1_column2)
+#   - index_sub2_on_column1_column2 (attached to index_child1_on_column1_column2)
+#   - index_child2_on_column1_column2 (attached to custom_name_idx)
+safe_add_concurrent_partitioned_index :partitioned_table, [:column1, :column2], name: "custom_name_idx", using: :hash
+```
+
+Note:
+
+This method runs multiple DDL statements non-transactionally.
+Creating or attaching an index on a child table could fail.
+In such cases an exception will be raised, and an `INVALID` index will be left on the parent table.
+
 #### 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.
@@ -220,11 +268,174 @@ 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
 
-Safely acquire a lock for a table.
+Safely acquire an access exclusive lock for a table.
 
 ```ruby
 safely_acquire_lock_for_table(:table) do
@@ -232,6 +443,19 @@ safely_acquire_lock_for_table(:table) do
 end
 ```
 
+Safely acquire a lock for a table in a different mode.
+
+```ruby
+safely_acquire_lock_for_table(:table, mode: :share) do
+  ...
+end
+```
+
+Note:
+
+We enforce that only one table (or a table and its partitions) can be locked at a time.
+Attempting to acquire a nested lock on a different table will result in an error.
+
 #### adjust\_lock\_timeout
 
 Adjust lock timeout.
@@ -260,6 +484,22 @@ Set maintenance work mem.
 safe_set_maintenance_work_mem_gb 1
 ```
 
+#### ensure\_small\_table!
+
+Ensure a table on disk is below the default threshold (10 megabytes).
+This will raise an error if the table is too large.
+
+```ruby
+ensure_small_table! :table
+```
+
+Ensure a table on disk is below a custom threshold and is empty.
+This will raise an error if the table is too large and/or contains data.
+
+```ruby
+ensure_small_table! :table, empty: true, threshold: 100.megabytes
+```
+
 ### Configuration
 
 The gem can be configured in an initializer.
@@ -274,8 +514,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 +546,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:-16}
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_PASSWORD=${PGPASSWORD:-postgres}

data/gemfiles/rails_6.1.gemfile

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

data/gemfiles/rails_7.0.gemfile

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

data/gemfiles/{rails_5.1.gemfile → rails_7.1.gemfile}

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

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, 6.0, 6.1, 7.0].map do |v|
+  ALLOWED_VERSIONS = [4.2, 5.0, 5.1, 5.2, 6.0, 6.1, 7.0, 7.1].map do |v|
     begin
       ActiveRecord::Migration[v]
     rescue ArgumentError

data/lib/pg_ha_migrations/blocking_database_transactions.rb

@@ -1,13 +1,18 @@
 module PgHaMigrations
   class BlockingDatabaseTransactions
     LongRunningTransaction = Struct.new(:database, :current_query, :state, :transaction_age, :tables_with_locks) do
+      def initialize(*args)
+        super
+
+        self.tables_with_locks = tables_with_locks.map { |args| Table.new(*args) }.select(&:present?)
+      end
+
       def description
-        locked_tables = tables_with_locks.compact
         [
           database,
-          locked_tables.size > 0 ? "tables (#{locked_tables.join(', ')})" : nil,
+          tables_with_locks.size > 0 ? "tables (#{tables_with_locks.map(&:fully_qualified_name).join(', ')})" : nil,
           "#{idle? ? "currently idle " : ""}transaction open for #{transaction_age}",
-          "#{idle? ? "last " : ""}query: #{current_query}"
+          "#{idle? ? "last " : ""}query: #{current_query}",
         ].compact.join(" | ")
       end
 
@@ -43,7 +48,7 @@ module PgHaMigrations
           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
+          array_agg(distinct array[c.relname, ns.nspname, l.mode]) AS tables_with_locks
         FROM pg_stat_activity psa -- Cluster wide
           LEFT JOIN pg_locks l ON (psa.#{pid_column} = l.pid)  -- Cluster wide
           LEFT JOIN pg_class c ON ( -- Database wide
@@ -56,7 +61,7 @@ module PgHaMigrations
             l.locktype != 'relation'
             OR (
                ns.nspname != 'pg_catalog'
-               AND c.relkind = 'r'
+               AND c.relkind IN ('r', 'p') -- 'r' is a standard table; 'p' is a partition parent
             )
           )
           AND psa.xact_start < clock_timestamp() - ?::interval

data/lib/pg_ha_migrations/hacks/add_index_on_only.rb

@@ -0,0 +1,30 @@
+require "active_record/connection_adapters/postgresql_adapter"
+require "active_record/connection_adapters/postgresql/schema_creation"
+
+module PgHaMigrations
+  module ActiveRecordHacks
+    module IndexAlgorithms
+      def index_algorithms
+        super.merge(only: "ONLY")
+      end
+    end
+
+    module CreateIndexDefinition
+      def visit_CreateIndexDefinition(o)
+        if o.algorithm == "ONLY"
+          o.algorithm = nil
+
+          quoted_index = quote_column_name(o.index.name)
+          quoted_table = quote_table_name(o.index.table)
+
+          super.sub("#{quoted_index} ON #{quoted_table}", "#{quoted_index} ON ONLY #{quoted_table}")
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(PgHaMigrations::ActiveRecordHacks::IndexAlgorithms)
+ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaCreation.prepend(PgHaMigrations::ActiveRecordHacks::CreateIndexDefinition)

data/lib/pg_ha_migrations/hacks/disable_ddl_transaction.rb

@@ -12,4 +12,3 @@ module PgHaMigrations
 end
 
 ActiveRecord::Migration.singleton_class.prepend(PgHaMigrations::ActiveRecordHacks::DisableDdlTransaction)
-