pg_ha_migrations 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd0329ccdae5b3bf68ac759bc0eca2dbc5089c3d91f9ee6444c6791a2bd42e93
-  data.tar.gz: ecf840233b36ede3ef278411bac124cefa32036b43d62119792a8d74ac126b5e
+  metadata.gz: 7b2e6bb12c48cffbc58e2f182f6d147f9952fd5167b82feaebee77190d0c71f0
+  data.tar.gz: f438b6095e6493bae0545cca0f9b3b3e5aa6d2dfc14d80a8c851e80f5b90e09d
 SHA512:
-  metadata.gz: f744006470a25bff85e10026f750e1cada2b49a19809cc2279208f9ec10ac86bfacf38dbbe32bd839f655475d0dde773d1c219b584c4a5cccc7c911f570c10bd
-  data.tar.gz: 5626ac149515ef764e63797cceed133c87d6032f22100a4940573a42a0b1ae483cbebc8a26596cc77494c4420e94e55d08e74b44ebe6fb83cd7f18e1a502d731
+  metadata.gz: 85b57ebf531422f9b14ff7d3e91a0759b9e4c714dd8b53dff2e5e45e0b44fe583ab726ad9a160f5d34de0bab102da0770caae5dad622e5294d4d8eba1b178a52
+  data.tar.gz: 2992367de5df4a1b57bcd024c39edebf40ecd5cc595a2b2b8034cd89af60d9bb068a4029e8771f66abf0fc7c0a73966d7c06bb0959c678df264e874276b5e73b

data/.github/workflows/ci.yml

@@ -9,6 +9,7 @@ jobs:
           - 14
           - 15
           - 16
+          - 17
         ruby:
           - "3.2"
           - "3.3"
@@ -17,7 +18,15 @@ jobs:
           - rails_7.1
           - rails_7.2
           - rails_8.0
-    name: PostgreSQL ${{ matrix.pg }} - Ruby ${{ matrix.ruby }} - ${{ matrix.gemfile }}
+        partman:
+          - 4
+          - 5
+        exclude:
+          - pg: 17
+            partman: 4 # Partman 4.x is not available in PGDG for PG 17
+          - pg: 13
+            partman: 5 # Partman 5.x is not available in PGDG for PG 13
+    name: PostgreSQL ${{ matrix.pg }} - Partman ${{ matrix.partman }} - 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
@@ -28,6 +37,7 @@ jobs:
         run: docker compose up -d --build
         env:
           PGVERSION: ${{ matrix.pg }}
+          PARTMAN_VERSION: ${{ matrix.partman }}
       - name: Setup Ruby using .ruby-version file
         uses: ruby/setup-ruby@v1
         with:

data/Dockerfile

@@ -1,6 +1,7 @@
 ARG PGVERSION
+ARG PARTMAN_VERSION
 
-FROM postgres:$PGVERSION-bullseye
+FROM postgres:$PGVERSION-bookworm AS base
 
 RUN apt-get update && apt-get install -y curl ca-certificates gnupg lsb-release
 
@@ -8,4 +9,11 @@ RUN curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | te
 
 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
+FROM base AS partman-4-branch
+ENV PARTMAN_VERSION=4.7.4-2.pgdg120+1
+
+FROM base AS partman-5-branch
+ENV PARTMAN_VERSION=5.2.4-1.pgdg120+1
+
+FROM partman-$PARTMAN_VERSION-branch AS final
+RUN apt update && apt-get install -y postgresql-$PG_MAJOR-partman=$PARTMAN_VERSION

data/README.md

@@ -144,9 +144,7 @@ Unsafely change the value of an enum type entry.
 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.
+> **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
 
@@ -178,7 +176,7 @@ safe_change_column_default :table, :column, -> { "NOW()" }
 safe_change_column_default :table, :column, -> { "'NOW()'" }
 ```
 
-Note: On Postgres 11+ adding a column with a constant default value does not rewrite or scan the table (under a lock or otherwise). In that case a migration adding a column with a default should do so in a single operation rather than the two-step `safe_add_column` followed by `safe_change_column_default`. We enforce this best practice with the error `PgHaMigrations::BestPracticeError`, but if your prefer otherwise (or are running in a mixed Postgres version environment), you may opt out by setting `config.prefer_single_step_column_addition_with_default = false` [in your configuration initializer](#configuration).
+> **Note:** On Postgres 11+ adding a column with a constant default value does not rewrite or scan the table (under a lock or otherwise). In that case a migration adding a column with a default should do so in a single operation rather than the two-step `safe_add_column` followed by `safe_change_column_default`. We enforce this best practice with the error `PgHaMigrations::BestPracticeError`, but if your prefer otherwise (or are running in a mixed Postgres version environment), you may opt out by setting `config.prefer_single_step_column_addition_with_default = false` [in your configuration initializer](#configuration).
 
 #### safe\_make\_column\_nullable
 
@@ -189,15 +187,15 @@ safe_make_column_nullable :table, :column
 ```
 #### safe\_make\_column\_not\_nullable
 
-Safely make the column not nullable - adds a temporary constraint and uses that constraint to validate no values are null before altering the column, then removes the temporary constraint.
+Safely make the column not nullable. This method uses a `CHECK column IS NOT NULL` constraint to validate no values are null before altering the column. If such a constraint exists already, it is re-used, if it does not, a temporary constraint is added. Whether or not the constraint already existed, the constraint will be validated, if necessary, and removed after the column is marked `NOT NULL`.
 
 ```ruby
 safe_make_column_not_nullable :table, :column
 ```
 
 > **Note:**
-> - This method performs a full table scan to validate that no NULL values exist in the column. While no exclusive lock is held for this scan, on large tables the scan may take a long time.
-> - The method runs multiple DDL statements non-transactionally. Validating the constraint can fail. In such cases an exception will be raised, and an INVALID constraint will be left on the table.
+> - This method may perform a full table scan to validate that no NULL values exist in the column. While no exclusive lock is held for this scan, on large tables the scan may take a long time.
+> - The method runs multiple DDL statements non-transactionally. Validating the constraint can fail. In such cases an INVALID constraint will be left on the table. Calling `safe_make_column_not_nullable` again is safe.
 
 If you want to avoid a full table scan and have already added and validated a suitable CHECK constraint, consider using [`safe_make_column_not_nullable_from_check_constraint`](#safe_make_column_not_nullable_from_check_constraint) instead.
 
@@ -224,7 +222,7 @@ You should use [`safe_make_column_not_nullable`](#safe_make_column_not_nullable)
 
 This method will raise an error if the constraint does not exist, is not validated, or does not strictly enforce non-null values for the column.
 
-> **Note:**  We do not attempt to catch all possible proofs of `column IS NOT NULL` by means of an existing constraint; only a constraint with the exact definition `column IS NOT NULL` will be recognized.
+> **Note:** We do not attempt to catch all possible proofs of `column IS NOT NULL` by means of an existing constraint; only a constraint with the exact definition `column IS NOT NULL` will be recognized.
 
 #### safe\_add\_index\_on\_empty\_table
 
@@ -285,11 +283,10 @@ Add a composite index using the `hash` index type with custom name for the paren
 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.
+> **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
 
@@ -383,7 +380,7 @@ The rest are keyword args with the following mappings:
 - `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.
+> **Note:** We have chosen to require PostgreSQL 11+ and hardcode `p_type` to `native` (`range` in the case of Partman 5) 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:
@@ -400,7 +397,7 @@ safe_create_partitioned_table :table, type: :range, partition_key: :created_at d
   t.timestamps null: false
 end
 
-safe_partman_create_parent :table, partition_key: :created_at, interval: "weekly"
+safe_partman_create_parent :table, partition_key: :created_at, interval: "1 week"
 ```
 
 With custom overrides:
@@ -418,7 +415,7 @@ end
 
 safe_partman_create_parent :table,
   partition_key: :created_at,
-  interval: "weekly",
+  interval: "1 week",
   template_table: :table_template,
   premake: 10,
   start_partition: Time.current + 1.month,
@@ -442,7 +439,7 @@ Allowed keyword args:
 - `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.
+> **Note:** If `inherit_privileges` will change then `safe_partman_reapply_privileges` will be automatically called to ensure permissions are propagated to existing child partitions.
 
 ```ruby
 safe_partman_update_config :table,
@@ -471,6 +468,29 @@ If your partitioned table is configured with `inherit_privileges` set to `true`,
 safe_partman_reapply_privileges :table
 ```
 
+#### unsafe\_partman\_standardize\_partition\_naming
+
+This method provides functionality to standardize existing Partman 4 tables such that naming is consistent with Partman 5.
+The logic follows the guidelines in the [Partman upgrade docs](https://github.com/pgpartman/pg_partman/blob/v5.2.4/doc/pg_partman_5.0.1_upgrade.md).
+
+Technically, only `weekly` and `quarterly` partitioned tables _need_ to be standardized prior to the upgrade.
+_However_, Partman 5 changes the default [datetime_string](https://github.com/pgpartman/pg_partman/blob/v5.2.4/sql/functions/calculate_time_partition_info.sql#L13-L17) that is used for _all_ intervals (`YYYYMMDD` and `YYYYMMDD_HH24MISS`).
+Compare that to the Partman 4 logic for [datetime_string](https://github.com/pgpartman/pg_partman/blob/v4.7.4/sql/functions/create_parent.sql#L434-L459).
+So, this method supports standardization for _all_ Partman 4 intervals.
+
+> **Note:** This method is safe from a database perspective, but is only safe from an application perspective if child tables are not directly referenced (child tables are renamed during this operation)
+
+```ruby
+unsafe_partman_standardize_partition_naming :table
+```
+
+This method uses a default statement timeout of 1 second.
+If the target table has many partitions (hundreds of thousands), you may need to increase the statement timeout for the operation to succeed.
+
+```ruby
+unsafe_partman_standardize_partition_naming :table, statement_timeout: 2
+```
+
 ### Utilities
 
 #### safely\_acquire\_lock\_for\_table
@@ -505,10 +525,8 @@ safely_acquire_lock_for_table(:table_a, :table_b, mode: :exclusive) do
 end
 ```
 
-Note:
-
-We enforce that only one set of tables can be locked at a time.
-Attempting to acquire a nested lock on a different set of tables will result in an error.
+> **Note:** We enforce that only one set of tables can be locked at a time.
+> Attempting to acquire a nested lock on a different set of tables will result in an error.
 
 #### adjust\_lock\_timeout
 
@@ -571,6 +589,7 @@ end
 - `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: `true`
 - `allow_force_create_table`: If false, the `force: true` option to ActiveRecord's `create_table` method is disallowed. Default: `false`
 - `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`
+- `partman_5_compatibility_mode`: If true, `safe_partman_create_parent` will raise an error if the user provides an interval that is [not supported by Partman 5](https://github.com/pgpartman/pg_partman/blob/v5.2.4/sql/functions/create_parent.sql#L86-L96). If the interval is supported, the method will ensure table name suffixes match the Partman 5 format (`YYYYMMDD`, `YYYYMMDD_HTH24MISS`). Default: `false`
 
 ### Rake Tasks
 
@@ -606,7 +625,7 @@ 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`, 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`.
+> **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`.
 
 ## Contributing
 

data/docker-compose.yml

@@ -4,7 +4,8 @@ services:
     build:
       context: .
       args:
-        - PGVERSION=${PGVERSION:-16}
+        - PGVERSION=${PGVERSION:-17}
+        - PARTMAN_VERSION=${PARTMAN_VERSION:-5}
     ports:
       - "5432:5432"
     environment:

data/lib/pg_ha_migrations/constraint.rb

@@ -1 +1,8 @@
-PgHaMigrations::CheckConstraint = Struct.new(:name, :definition, :validated)
+PgHaMigrations::CheckConstraint = Struct.new(:name, :definition, :validated) do
+  def initialize(name, definition, validated)
+    # pg_get_constraintdef includes NOT VALID in the definition,
+    # but we return that as a separate attribute.
+    definition = definition&.gsub(/ NOT VALID\Z/, "")
+    super(name, definition, validated)
+  end
+end

data/lib/pg_ha_migrations/extension.rb

@@ -0,0 +1,35 @@
+module PgHaMigrations
+  class Extension
+    attr_reader :name, :schema, :version
+
+    def initialize(name)
+      @name = name
+
+      @schema, @version = ActiveRecord::Base.connection.select_rows(<<~SQL).first
+        SELECT nspname, extversion
+        FROM pg_namespace JOIN pg_extension
+          ON pg_namespace.oid = pg_extension.extnamespace
+        WHERE pg_extension.extname = #{ActiveRecord::Base.connection.quote(name)}
+        LIMIT 1
+      SQL
+    end
+
+    def quoted_schema
+      return unless schema
+
+      PG::Connection.quote_ident(schema)
+    end
+
+    def major_version
+      return unless version
+
+      Gem::Version.new(version)
+        .segments
+        .first
+    end
+
+    def installed?
+      !!schema && !!version
+    end
+  end
+end

data/lib/pg_ha_migrations/partman_config.rb

@@ -1,11 +1,73 @@
 # This is an internal class that is not meant to be used directly
 class PgHaMigrations::PartmanConfig < ActiveRecord::Base
+  SUPPORTED_PARTITION_TYPES = %w[native range]
+
+  delegate :connection, to: :class
+
   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"
+  def self.find(parent_table, partman_extension:)
+    unless partman_extension.installed?
+      raise PgHaMigrations::MissingExtensionError, "The pg_partman extension is not installed"
+    end
+
+    self.table_name = "#{partman_extension.quoted_schema}.part_config"
+
+    super(parent_table)
+  end
+
+  # The actual column type is TEXT and the value is determined by the
+  # intervalstyle in Postgres at the time create_parent is called.
+  # Rails hard codes this config when it builds connections for ease
+  # of parsing by ActiveSupport::Duration.parse. So in theory, we
+  # really only need to do the interval casting, but we're doing the
+  # SET LOCAL to be absolutely sure intervalstyle is correct.
+  #
+  # https://github.com/rails/rails/blob/v8.0.3/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L979-L980
+  def partition_interval_iso_8601
+    transaction do
+      connection.execute("SET LOCAL intervalstyle TO 'iso_8601'")
+      connection.select_value("SELECT #{connection.quote(partition_interval)}::interval")
+    end
+  end
+
+  def partition_rename_adapter
+    unless SUPPORTED_PARTITION_TYPES.include?(partition_type)
+      raise PgHaMigrations::InvalidPartmanConfigError,
+        "Expected partition_type to be in #{SUPPORTED_PARTITION_TYPES.inspect} " \
+        "but received #{partition_type.inspect}"
+    end
+
+    duration = ActiveSupport::Duration.parse(partition_interval_iso_8601)
+
+    if duration.parts.size != 1
+      raise PgHaMigrations::InvalidPartmanConfigError,
+        "Partition renaming for complex partition_interval #{duration.iso8601.inspect} not supported"
+    end
+
+    # Quarterly and weekly have special meaning in Partman 4 with
+    # specific datetime strings that need to be handled separately.
+    #
+    # The intervals "1 week" and "3 months" will not match the first
+    # two conditionals and will fallthrough to standard adapters below.
+    if duration == 1.week && datetime_string == "IYYY\"w\"IW"
+      PgHaMigrations::WeeklyPartmanRenameAdapter.new(self)
+    elsif duration == 3.months && datetime_string == "YYYY\"q\"Q"
+      PgHaMigrations::QuarterlyPartmanRenameAdapter.new(self)
+    elsif duration >= 1.year
+      PgHaMigrations::YearToForeverPartmanRenameAdapter.new(self)
+    elsif duration >= 1.month && duration < 1.year
+      PgHaMigrations::MonthToYearPartmanRenameAdapter.new(self)
+    elsif duration >= 1.day && duration < 1.month
+      PgHaMigrations::DayToMonthPartmanRenameAdapter.new(self)
+    elsif duration >= 1.minute && duration < 1.day
+      PgHaMigrations::MinuteToDayPartmanRenameAdapter.new(self)
+    elsif duration >= 1.second && duration < 1.minute
+      PgHaMigrations::SecondToMinutePartmanRenameAdapter.new(self)
+    else
+      raise PgHaMigrations::InvalidPartmanConfigError,
+        "Expected partition_interval to be greater than 1 second " \
+        "but received #{duration.iso8601.inspect}"
+    end
   end
 end

data/lib/pg_ha_migrations/partman_rename_adapter.rb

@@ -0,0 +1,209 @@
+module PgHaMigrations
+  class AbstractPartmanRenameAdapter
+    def initialize(part_config)
+      if part_config.datetime_string != source_datetime_string
+        raise PgHaMigrations::InvalidPartmanConfigError,
+          "Expected datetime_string to be #{source_datetime_string.inspect} " \
+          "but received #{part_config.datetime_string.inspect}"
+      end
+    end
+
+    def alter_table_sql(partitions)
+      sql = partitions.filter_map do |partition|
+        next if partition.name =~ /\A.+_default\z/
+
+        if partition.name !~ source_name_suffix_pattern
+          raise PgHaMigrations::InvalidIdentifierError,
+            "Expected #{partition.name.inspect} to match #{source_name_suffix_pattern.inspect}"
+        end
+
+        begin
+          "ALTER TABLE #{partition.fully_qualified_name} RENAME TO #{target_table_name(partition.name)};"
+        rescue Date::Error
+          raise PgHaMigrations::InvalidIdentifierError,
+            "Expected #{partition.name.inspect} suffix to be a parseable DateTime"
+        end
+      end.join("\n")
+
+      # This wraps the SQL in an anonymous function such that
+      # the statement timeout would apply to the entire batch of
+      # statements instead of each individual statement
+      "DO $$ BEGIN #{sql} END; $$;"
+    end
+
+    def target_table_name(table_name)
+      raise "#{__method__} should be implemented in subclass"
+    end
+
+    def source_datetime_string
+      raise "#{__method__} should be implemented in subclass"
+    end
+
+    def source_name_suffix_pattern
+      raise "#{__method__} should be implemented in subclass"
+    end
+
+    def target_datetime_string
+      raise "#{__method__} should be implemented in subclass"
+    end
+  end
+
+  class YearToForeverPartmanRenameAdapter < AbstractPartmanRenameAdapter
+    def target_table_name(table_name)
+      table_name + "0101"
+    end
+
+    def source_datetime_string
+      "YYYY"
+    end
+
+    def source_name_suffix_pattern
+      /\A.+_p\d{4}\z/
+    end
+
+    def target_datetime_string
+      "YYYYMMDD"
+    end
+  end
+
+   class QuarterlyPartmanRenameAdapter < AbstractPartmanRenameAdapter
+    QUARTER_MONTH_MAPPING = {
+      "1" => "01",
+      "2" => "04",
+      "3" => "07",
+      "4" => "10",
+    }
+
+    def target_table_name(table_name)
+      base_name = table_name[0...-6]
+
+      year = table_name.last(6).first(4)
+
+      month = QUARTER_MONTH_MAPPING.fetch(table_name.last(1))
+
+      base_name + year + month + "01"
+    end
+
+    def source_datetime_string
+      "YYYY\"q\"Q"
+    end
+
+    def source_name_suffix_pattern
+      /\A.+_p\d{4}q(1|2|3|4)\z/
+    end
+
+    def target_datetime_string
+      "YYYYMMDD"
+    end
+  end
+
+   class MonthToYearPartmanRenameAdapter < AbstractPartmanRenameAdapter
+    def target_table_name(table_name)
+      base_name = table_name[0...-7]
+
+      partition_datetime = DateTime.strptime(table_name.last(7), "%Y_%m")
+
+      base_name + partition_datetime.strftime("%Y%m%d")
+    end
+
+    def source_datetime_string
+      "YYYY_MM"
+    end
+
+    def source_name_suffix_pattern
+      /\A.+_p\d{4}_\d{2}\z/
+    end
+
+    def target_datetime_string
+      "YYYYMMDD"
+    end
+  end
+
+   class WeeklyPartmanRenameAdapter < AbstractPartmanRenameAdapter
+    def target_table_name(table_name)
+      base_name = table_name[0...-7]
+
+      partition_datetime = DateTime.strptime(table_name.last(7), "%Gw%V")
+
+      base_name + partition_datetime.strftime("%Y%m%d")
+    end
+
+    def source_datetime_string
+      "IYYY\"w\"IW"
+    end
+
+    def source_name_suffix_pattern
+      /\A.+_p\d{4}w\d{2}\z/
+    end
+
+    def target_datetime_string
+      "YYYYMMDD"
+    end
+  end
+
+   class DayToMonthPartmanRenameAdapter < AbstractPartmanRenameAdapter
+    def target_table_name(table_name)
+      base_name = table_name[0...-10]
+
+      partition_datetime = DateTime.strptime(table_name.last(10), "%Y_%m_%d")
+
+      base_name + partition_datetime.strftime("%Y%m%d")
+    end
+
+    def source_datetime_string
+      "YYYY_MM_DD"
+    end
+
+    def source_name_suffix_pattern
+      /\A.+_p\d{4}_\d{2}_\d{2}\z/
+    end
+
+    def target_datetime_string
+      "YYYYMMDD"
+    end
+  end
+
+   class MinuteToDayPartmanRenameAdapter < AbstractPartmanRenameAdapter
+    def target_table_name(table_name)
+      base_name = table_name[0...-15]
+
+      partition_datetime = DateTime.strptime(table_name.last(15), "%Y_%m_%d_%H%M")
+
+      base_name + partition_datetime.strftime("%Y%m%d_%H%M%S")
+    end
+
+    def source_datetime_string
+      "YYYY_MM_DD_HH24MI"
+    end
+
+    def source_name_suffix_pattern
+      /\A.+_p\d{4}_\d{2}_\d{2}_\d{4}\z/
+    end
+
+    def target_datetime_string
+      "YYYYMMDD_HH24MISS"
+    end
+  end
+
+   class SecondToMinutePartmanRenameAdapter < AbstractPartmanRenameAdapter
+    def target_table_name(table_name)
+      base_name = table_name[0...-17]
+
+      partition_datetime = DateTime.strptime(table_name.last(17), "%Y_%m_%d_%H%M%S")
+
+      base_name + partition_datetime.strftime("%Y%m%d_%H%M%S")
+    end
+
+    def source_datetime_string
+      "YYYY_MM_DD_HH24MISS"
+    end
+
+    def source_name_suffix_pattern
+      /\A.+_p\d{4}_\d{2}_\d{2}_\d{6}\z/
+    end
+
+    def target_datetime_string
+      "YYYYMMDD_HH24MISS"
+    end
+  end
+end

data/lib/pg_ha_migrations/relation.rb

@@ -139,6 +139,30 @@ module PgHaMigrations
     end
   end
 
+  class PartmanTable < Table
+    IDENTIFIER_REGEX = /^[a-z_][a-z_\d]*$/
+
+    def initialize(name, schema, mode=nil)
+      if name !~ IDENTIFIER_REGEX
+        raise InvalidIdentifierError, "Partman requires table names to be lowercase with underscores"
+      end
+
+      if schema !~ IDENTIFIER_REGEX
+        raise InvalidIdentifierError, "Partman requires schema names to be lowercase with underscores"
+      end
+
+      super
+    end
+
+    def fully_qualified_name
+      "#{schema}.#{name}"
+    end
+
+    def part_config(partman_extension:)
+      PgHaMigrations::PartmanConfig.find(fully_qualified_name, partman_extension: partman_extension)
+    end
+  end
+
   class Index < Relation
     MAX_NAME_SIZE = 63 # bytes
 

data/lib/pg_ha_migrations/safe_statements.rb

@@ -3,6 +3,10 @@ module PgHaMigrations::SafeStatements
     @safe_added_columns_without_default_value ||= []
   end
 
+  def partman_extension
+    @partman_extension ||= PgHaMigrations::Extension.new("pg_partman")
+  end
+
   def safe_create_table(table, **options, &block)
     if options[:force]
       raise PgHaMigrations::UnsafeMigrationError.new(":force is NOT SAFE! Explicitly call unsafe_drop_table first if you want to recreate an existing table")
@@ -139,23 +143,39 @@ module PgHaMigrations::SafeStatements
     end
 
     validated_table = PgHaMigrations::Table.from_table_name(table)
-    tmp_constraint_name = "tmp_not_null_constraint_#{OpenSSL::Digest::SHA256.hexdigest(column.to_s).first(7)}"
+    quoted_column_name = connection.quote_column_name(column)
+    column_str = column.to_s
 
-    if validated_table.check_constraints.any? { |c| c.name == tmp_constraint_name }
-      raise PgHaMigrations::InvalidMigrationError, "A constraint #{tmp_constraint_name.inspect} already exists. " \
-        "This implies that a previous invocation of this method failed and left behind a temporary constraint. " \
-        "Please drop the constraint before attempting to run this method again."
-    end
+    # First, look for existing constraints that match the IS NOT NULL pattern for this column
+    existing_constraint = validated_table.check_constraints.select do |c|
+      c.definition =~ /\ACHECK \(*(#{Regexp.escape(column_str)}|#{Regexp.escape(quoted_column_name)}) IS NOT NULL\)*\Z/i
+    end.first
+
+    constraint_name = nil
+    if existing_constraint
+      if existing_constraint.validated
+        say "Found existing validated constraint #{existing_constraint.inspect} for column #{column_str}, using it directly"
+      else
+        say "Found existing unvalidated constraint #{existing_constraint.inspect} for column #{column_str}, validating it first"
+        safe_validate_check_constraint(table, name: existing_constraint.name)
+      end
+      constraint_name = existing_constraint.name
+    else
+      # Create a temporary constraint if no matching constraints exist
+      constraint_name = "tmp_not_null_constraint_#{OpenSSL::Digest::SHA256.hexdigest(column.to_s).first(7)}"
 
-    safe_add_unvalidated_check_constraint(table, "#{connection.quote_column_name(column)} IS NOT NULL", name: tmp_constraint_name)
-    safe_validate_check_constraint(table, name: tmp_constraint_name)
+      safe_add_unvalidated_check_constraint(table, "#{quoted_column_name} IS NOT NULL", name: constraint_name)
+      safe_validate_check_constraint(table, name: constraint_name)
+    end
 
     # "Ordinarily this is checked during the ALTER TABLE by scanning the entire table; however, if a
     # valid CHECK constraint is found which proves no NULL can exist, then the table scan is
     # skipped."
     # See: https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-DESC-SET-DROP-NOT-NULL
     unsafe_make_column_not_nullable(table, column)
-    unsafe_remove_constraint(table, name: tmp_constraint_name)
+
+    # Always drop the constraint at the end, whether it was existing or temporary
+    unsafe_remove_constraint(table, name: constraint_name)
   end
 
   # This method is a variant of `safe_make_column_not_nullable` that is expected to always be fast;
@@ -458,6 +478,18 @@ module PgHaMigrations::SafeStatements
       raise PgHaMigrations::InvalidMigrationError, "Native partitioning with partman not supported on Postgres databases before version 11"
     end
 
+    raise PgHaMigrations::MissingExtensionError, "The pg_partman extension is not installed" unless partman_extension.installed?
+
+    if partman_extension.major_version >= 5 || PgHaMigrations.config.partman_5_compatibility_mode
+      if PgHaMigrations::PARTMAN_UNSUPPORTED_INTERVALS.include?(interval)
+        raise PgHaMigrations::InvalidMigrationError,
+          "Special partition interval values (#{interval}) are no longer supported. " \
+          "Please use a supported interval time value from core PostgreSQL " \
+          "#{(partman_extension.major_version < 5 ? "or turn partman 5 compatibility mode off " : "")}" \
+          "(https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-INTERVAL-INPUT)"
+      end
+    end
+
     formatted_start_partition = nil
 
     if start_partition.present?
@@ -472,16 +504,22 @@ module PgHaMigrations::SafeStatements
       end
     end
 
+    validated_table = PgHaMigrations::PartmanTable.from_table_name(table)
+    validated_template_table = template_table ? PgHaMigrations::PartmanTable.from_table_name(template_table) : nil
+
     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,
+      parent_table: validated_table.fully_qualified_name,
+      template_table: validated_template_table&.fully_qualified_name,
       control: partition_key,
-      type: "native",
       interval: interval,
       premake: premake,
       start_partition: formatted_start_partition,
     }.compact
 
+    if partman_extension.major_version < 5
+      create_parent_options[:type] = "native"
+    end
+
     create_parent_sql = create_parent_options.map { |k, v| "p_#{k} := #{connection.quote(v)}" }.join(", ")
 
     log_message = "partman_create_parent(#{table.inspect}, " \
@@ -492,7 +530,7 @@ module PgHaMigrations::SafeStatements
       "template_table: #{template_table.inspect})"
 
     say_with_time(log_message) do
-      connection.execute("SELECT #{_quoted_partman_schema}.create_parent(#{create_parent_sql})")
+      connection.execute("SELECT #{partman_extension.quoted_schema}.create_parent(#{create_parent_sql})")
     end
 
     update_config_options = {
@@ -503,6 +541,10 @@ module PgHaMigrations::SafeStatements
     }.compact
 
     unsafe_partman_update_config(table, **update_config_options)
+
+    if PgHaMigrations.config.partman_5_compatibility_mode && partman_extension.major_version < 5
+      unsafe_partman_standardize_partition_naming(table)
+    end
   end
 
   def safe_partman_update_config(table, **options)
@@ -514,32 +556,13 @@ module PgHaMigrations::SafeStatements
   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::MissingExtensionError, "The pg_partman extension is not installed" unless partman_extension.installed?
 
-    raise PgHaMigrations::InvalidMigrationError, "The pg_partman extension is not installed" unless schema.present?
+    validated_table = PgHaMigrations::PartmanTable.from_table_name(table)
 
-    connection.quote_schema_name(schema)
-  end
-
-  def _fully_qualified_table_name_for_partman(table)
-    table = PgHaMigrations::Table.from_table_name(table)
-
-    [table.schema, table.name].each do |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.join(".")
+    say_with_time "partman_reapply_privileges(#{table.inspect})" do
+      connection.execute("SELECT #{partman_extension.quoted_schema}.reapply_privileges('#{validated_table.fully_qualified_name}')")
+    end
   end
 
   def _per_migration_caller

data/lib/pg_ha_migrations/unsafe_statements.rb

@@ -196,21 +196,55 @@ module PgHaMigrations::UnsafeStatements
 
     raise ArgumentError, "Unrecognized argument(s): #{invalid_options}" unless invalid_options.empty?
 
-    PgHaMigrations::PartmanConfig.schema = _quoted_partman_schema
+    part_config = PgHaMigrations::PartmanTable
+      .from_table_name(table)
+      .part_config(partman_extension: partman_extension)
 
-    config = PgHaMigrations::PartmanConfig.find(_fully_qualified_table_name_for_partman(table))
+    part_config.assign_attributes(**options)
 
-    config.assign_attributes(**options)
-
-    inherit_privileges_changed = config.inherit_privileges_changed?
+    inherit_privileges_changed = part_config.inherit_privileges_changed?
 
     say_with_time "partman_update_config(#{table.inspect}, #{options.map { |k,v| "#{k}: #{v.inspect}" }.join(", ")})" do
-      config.save!
+      part_config.save!
     end
 
     safe_partman_reapply_privileges(table) if inherit_privileges_changed
   end
 
+  def unsafe_partman_standardize_partition_naming(table, statement_timeout: 1)
+    raise PgHaMigrations::MissingExtensionError, "The pg_partman extension is not installed" unless partman_extension.installed?
+    raise PgHaMigrations::InvalidMigrationError, "This method is only available for pg_partman major version 4" unless partman_extension.major_version == 4
+
+    validated_table = PgHaMigrations::PartmanTable.from_table_name(table)
+
+    part_config = validated_table.part_config(partman_extension: partman_extension)
+    partition_rename_adapter = part_config.partition_rename_adapter
+
+    before_automatic_maintenance = part_config.automatic_maintenance
+
+    part_config.update!(automatic_maintenance: "off") if before_automatic_maintenance == "on"
+
+    begin
+      partitions = validated_table.partitions
+      alter_table_sql = partition_rename_adapter.alter_table_sql(partitions)
+
+      log_message = "partman_standardize_partition_naming(" \
+        "#{table.inspect}, statement_timeout: #{statement_timeout}) - " \
+        "Renaming #{partitions.size - 1} partition(s)" # excluding default partition
+
+      safely_acquire_lock_for_table(table) do
+        adjust_statement_timeout(statement_timeout) do
+          say_with_time(log_message) do
+            part_config.update!(datetime_string: partition_rename_adapter.target_datetime_string)
+            connection.execute(alter_table_sql)
+          end
+        end
+      end
+    ensure
+      part_config.reload.update!(automatic_maintenance: "on") if before_automatic_maintenance == "on"
+    end
+  end
+
   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

data/lib/pg_ha_migrations/version.rb

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

data/lib/pg_ha_migrations.rb

@@ -14,6 +14,7 @@ module PgHaMigrations
     :allow_force_create_table,
     :prefer_single_step_column_addition_with_default,
     :infer_primary_key_on_partitioned_tables,
+    :partman_5_compatibility_mode,
   )
 
   def self.config
@@ -22,7 +23,8 @@ module PgHaMigrations
       true,
       false,
       true,
-      true
+      true,
+      false,
     )
   end
 
@@ -44,6 +46,17 @@ module PgHaMigrations
     retention_keep_table
   ]
 
+  PARTMAN_UNSUPPORTED_INTERVALS = %w[
+    yearly
+    quarterly
+    monthly
+    weekly
+    daily
+    hourly
+    half-hour
+    quarter-hour
+  ]
+
   # Safe versus unsafe in this context specifically means the following:
   # - Safe operations will not block for long periods of time.
   # - Unsafe operations _may_ block for long periods of time.
@@ -69,13 +82,24 @@ module PgHaMigrations
   # 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)
+
+  # Some methods rely on certain extensions being installed (e.g. partman).
+  MissingExtensionError = Class.new(StandardError)
+
+  # Some methods require table / schema names to be in a specific format.
+  InvalidIdentifierError = Class.new(StandardError)
+
+  # Some methods require the part_config entry to be in a specific state.
+  InvalidPartmanConfigError = Class.new(StandardError)
 end
 
 require "pg_ha_migrations/constraint"
+require "pg_ha_migrations/extension"
 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/partman_rename_adapter"
 require "pg_ha_migrations/lock_mode"
 require "pg_ha_migrations/unsafe_statements"
 require "pg_ha_migrations/safe_statements"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_ha_migrations
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - celeen
@@ -13,7 +13,7 @@ authors:
 - redneckbeard
 bindir: exe
 cert_chain: []
-date: 2025-04-17 00:00:00.000000000 Z
+date: 2025-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -194,11 +194,13 @@ files:
 - 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/extension.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/partman_rename_adapter.rb
 - lib/pg_ha_migrations/railtie.rb
 - lib/pg_ha_migrations/relation.rb
 - lib/pg_ha_migrations/safe_statements.rb