partition_gardener 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ad4860950aedb375b6703ededf1602006203f1defa7406465f6f87b5d38083b
-  data.tar.gz: 0af3c3dadfe7c123c5193e9aa1b78b3d8fb5dc1a294a3819c790ad20b18a4d53
+  metadata.gz: abde0192951f5cc668d53ca847f119c3d9dcf5c994404504119cfb1d54c6be17
+  data.tar.gz: 47eab4f81f45acf7a59730e2a04ac48769e655557da78c0db12be355a85ce6b2
 SHA512:
-  metadata.gz: 68c44b5b9851c2f167801c26f33b9050f5ba684a0355820ea8738f7309ceebaf35ed3ab2ef3ee8a87830a145c9593b8a994f06ae7b3625901fb7b92963cec2d7
-  data.tar.gz: 8026d9241cf10f037655ded5999cae214dafe6658b6d3c66a5d336561e87d20b078a63a82321bed1d0b74d0b9b513579196dbe3d3d31235a61c10aedb6d864ab
+  metadata.gz: 51677ad1c0b6d9513a86e574e9254776a7b9cecbd83f230a38b61d1a3f04be5313987901658aa9aebbf78e47a0f5ddd9b9573c6b3396c599ac6c60fdc932ab96
+  data.tar.gz: f1f4271c57f3a1ed9eaf2ca2f47d351cb50f729377f21bfac7657ce9d5342067b8dbc4c005d3db926d9cbf25186fbf0f431d287daf8139111758c2d647e7ac8d

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 0.3.5 (2026-09-09)
+
+- Keep attached monthly children that already cover the start of the sliding-window active range, and fill the remainder as `_open` rather than overlapping `_current`
+- Start `_future` after premade months that occupy keys at or after the active window end, and skip `_future` when an occupying child already ends at MAXVALUE
+- Add the RFC process (RFC 0001) and a Proposed occupancy-first contract for `_current`, `_open`, and `_future` (RFC 0002)
+- Specify shipped registry, plan, CLI, layout, rebalance, lock, hot-switch, and column-align contracts as Stable RFCs 0003 through 0015
+
+## 0.3.4 (2026-09-02)
+
+- Align LIKE and detached children with additive parent columns before `ATTACH PARTITION`, preserving type, collation, default, and `NOT NULL` atomically. Audit warns when a managed child still lags. Set `align_child_columns: false` to fail fast instead.
+
 ## 0.3.3 (2026-08-13)
 
 - Roll the sliding-window current partition before attaching the prior month's archive so a month rollover detaches the old current span and attaches that month as its own child

data/README.md

@@ -41,9 +41,10 @@ Complements migration gems (e.g. [pg_party](https://github.com/rkrage/pg_party))
 - [docs/naming.md](docs/naming.md) — child partition naming catalog
 - [docs/host_testing.md](docs/host_testing.md) — CI and staging for host apps
 
-### Schemas
+### Schemas and RFCs
 
 - [docs/schemas/](docs/schemas/) — JSON schemas for registry and plan reports
+- [rfcs/](rfcs/) — design review; RFC 0002 Proposed tail slots; RFC 0003–0015 Stable shipped contracts
 
 ## Quick start
 

data/SECURITY.md

@@ -2,26 +2,24 @@
 
 ## Reporting a Vulnerability
 
-Do not open a public issue for security vulnerabilities.
-
 Email security details to: security@kiskolabs.com
 
-Include: description, steps to reproduce, potential impact, and suggested fix (if available).
+Send the report only to that address. Include description, steps to reproduce, potential impact, and a suggested fix when you have one.
 
 ### Response Timeline
 
-- We will acknowledge receipt of your report
-- We will provide an initial assessment
-- We will keep you informed of our progress and resolution timeline
+- We will acknowledge receipt of your report.
+- We will provide an initial assessment.
+- We will keep you informed of our progress and resolution timeline.
 
 ### Disclosure Policy
 
-- We will work with you to understand and resolve the issue
-- We will credit you for the discovery (unless you prefer to remain anonymous)
-- We will publish a security advisory after the vulnerability is patched
-- We will coordinate public disclosure with you
+- We will work with you to understand and resolve the issue.
+- We will credit you for the discovery unless you prefer to remain anonymous.
+- We will publish a security advisory after the vulnerability is patched.
+- We will coordinate public disclosure with you.
 
 ## Automation Security
 
-- Context Isolation: It is strictly forbidden to include production credentials, API keys, or Personally Identifiable Information (PII) in prompts sent to third-party LLMs or automation services.
-- Supply Chain: All automated dependencies must be verified.
+- Keep production credentials, API keys, and personal data out of prompts sent to third-party models or automation services.
+- Verify automated dependencies.

data/docs/THIRD_PARTY_LICENSE_MANIFEST.tsv

@@ -17,18 +17,18 @@ root	language_server-protocol	3.17.0.6	MIT
 root	lint_roller	1.1.0	MIT
 root	logger	1.7.0	Ruby|BSD-2-Clause
 root	minitest	6.0.6	MIT
-root	parallel	2.1.0	MIT
+root	parallel	2.2.0	MIT
 root	parser	3.3.12.0	MIT
-root	partition_gardener	0.3.3	MIT
+root	partition_gardener	0.3.5	MIT
 root	pg	1.6.3	BSD-2-Clause
-root	polyrun	2.2.2	MIT
+root	polyrun	2.2.4	MIT
 root	prism	1.9.0	MIT
 root	prosopite	2.2.0	Apache-2.0
 root	racc	1.8.1	Ruby|BSD-2-Clause
-root	rack	3.2.6	MIT
+root	rack	3.2.7	MIT
 root	rainbow	3.1.1	MIT
 root	rake	13.4.2	MIT
-root	rbs	4.1.2	BSD-2-Clause|Ruby
+root	rbs	4.2.0	BSD-2-Clause|Ruby
 root	regexp_parser	2.12.0	MIT
 root	rspec	3.13.2	MIT
 root	rspec-core	3.13.6	MIT

data/docs/audit_reference.md

@@ -36,6 +36,8 @@ Horizon warning threshold: 30 days (`Audit::HORIZON_WARNING_DAYS`). High child c
 
 `partition gap: no attached tail partition extends to MAXVALUE` — missing future/open tail. `apply` to attach `_future`.
 
+`child {name} is missing column {columns} from parent {table}` — a managed LIKE or detached child lacks ordinary columns added on the parent later. `apply` adds those columns atomically then attaches (default). Set `align_child_columns: false` to fail fast. Built-in naming schemes exclude unrelated prefixed tables; custom partition name formatters retain prefix discovery.
+
 Gap objects include `range_start`, `range_end`, and `message`.
 
 ## Plan report
@@ -120,6 +122,7 @@ Disable globally or per table if you do not want checkpoint storage ([configurat
 
 ## Related
 
+- [RFC 0005](../rfcs/0005-plan-audit-reports.md) — plan, audit, and RunSummary contract
 - [operations.md](operations.md) — remediation workflows
 - [monitoring.md](monitoring.md) — metrics from these fields
 - [naming.md](naming.md) — segment names in output

data/docs/cli.md

@@ -58,13 +58,14 @@ bundle exec partition_gardener --rails apply --confirm audits
 Apply all registered gardener-owned tables:
 
 ```bash
-bundle exec partition_gardener --rails apply --all
+bundle exec partition_gardener --rails apply --confirm --all
 ```
 
 Omitting a table name without `--all` also runs the full registry.
 
 ## Related
 
+- [RFC 0008](../rfcs/0008-cli.md) — verbs, confirm gate, table selection
 - [configuration.md](configuration.md) — registry format and global config
 - [background_job.md](background_job.md) — when to use a job instead of CLI apply
 - [audit_reference.md](audit_reference.md) — audit and plan output reference

data/docs/configuration.md

@@ -53,6 +53,8 @@ When the gem loads inside Rails, the railtie sets `connection_resolver` and `tod
 
 `retention_detach_concurrently` (default: `false`) — detach dropped archive partitions with `CONCURRENTLY` (global default).
 
+`align_child_columns` (default: `true`) — before `ATTACH PARTITION`, add ordinary parent columns that a LIKE or detached child is missing. Audit warns when a child still lags. Set `false` to fail fast when a child is missing those columns.
+
 ### Advisory locks
 
 Each table run acquires `pg_advisory_lock(hashtext('partition_gardener'), hashtext(table_name))` (or the transaction-scoped variant).
@@ -164,6 +166,8 @@ All templates accept shared options passed through to the registry hash:
 
 `retention_detach_concurrently` (default: global default) — per-table override for concurrent detach.
 
+`align_child_columns` (default: global default) — per-table override. Additive only: add missing ordinary columns in one statement (skip identity and generated), preserving type, non-default collation, default, and `NOT NULL`. If existing rows cannot satisfy `NOT NULL`, PostgreSQL rejects the complete alignment and leaves the child unchanged. Existing types, extra child columns, and other constraints stay as they are.
+
 `maintenance_backend` (default: `:gardener`) — `:gardener`, `:pg_partman`, or `:hybrid_layout_only`.
 
 `incremental_rebalance` (default: global default) — per-table override.
@@ -253,6 +257,8 @@ Registry entries are operator-controlled configuration, not end-user input.
 
 ## Related
 
+- [RFC 0004](../rfcs/0004-registry-json.md) — portable registry file
+- [RFC 0009](../rfcs/0009-maintenance-backends.md) — gardener, pg_partman, hybrid
 - [background_job.md](background_job.md) — schedule `run!` from a host job
 - [cli.md](cli.md) — plan, audit, apply from the shell
 - [decision_flow.md](decision_flow.md) — when and how to partition

data/docs/naming.md

@@ -8,13 +8,13 @@ Fixed suffixes on the parent table name:
 
 `{table}_default` — catch-all; must trend empty.
 
-`{table}_current` — start of active window.
+`{table}_current` — filler that starts at the active window origin. The span is the uncovered remainder of that window, not this calendar month or sequence id.
 
-`{table}_open` — gap filler in current zone.
+`{table}_open` — gap filler in the current zone when the origin is already a named child or a heat split. Extra fillers after that are `{table}_open_N`.
 
 `{table}_open_N` — extra fillers after heat splits.
 
-`{table}_future` — open-ended tail to MAXVALUE.
+`{table}_future` — open-ended tail to MAXVALUE. It starts at the first instant at or after the window end that no occupying child covers.
 
 `{table}_rebalance_staging` — temporary during tail rebalance.
 
@@ -66,6 +66,8 @@ Remediation: prefer `plan` + `apply` over manual attach. If manual children are
 
 ## Related
 
+- [RFC 0002](../rfcs/0002-tail-slots.md) — names and occupancy-first placement
+- [RFC 0006](../rfcs/0006-archive-naming.md) — date-bucket suffixes and parse-back
 - [operations.md](operations.md) — gap remediation
 - [cutover.md](cutover.md) — shadow `p_` prefix
 - [audit_reference.md](audit_reference.md) — gap messages

data/docs/retention.md

@@ -60,6 +60,7 @@ When `maintenance_backend: :pg_partman`, gardener skips the table; partman owns
 
 ## Related
 
+- [RFC 0007](../rfcs/0007-retention.md) — cutoff, preview, skip list
 - [decision_flow.md](decision_flow.md) — retention in layout choice
 - [operations.md](operations.md) — incident response
 - [monitoring.md](monitoring.md) — alerts

data/docs/schemas/partition_garden.schema.json

@@ -92,6 +92,10 @@
     "retention_detach_concurrently": {
       "type": "boolean"
     },
+    "align_child_columns": {
+      "type": "boolean",
+      "description": "When true (default), atomically add missing ordinary parent columns with their collation, default, and NOT NULL contract on a LIKE or detached child before ATTACH PARTITION"
+    },
     "hash_modulus": {
       "type": "integer",
       "minimum": 2,

data/lib/partition_gardener/audit.rb

@@ -61,6 +61,10 @@ module PartitionGardener
         warnings << "partition gap: #{gap.message}"
       end
 
+      warning_options = {}
+      warning_options[:candidate_table] = method(:managed_child_table?) if @config
+      warnings.concat(ChildColumnAlign.lagging_child_warnings(@table_name, **warning_options))
+
       AuditResult.new(
         table_name: @table_name,
         partitioned: true,
@@ -74,6 +78,18 @@ module PartitionGardener
 
     private
 
+    def managed_child_table?(child_table)
+      return true if @config[:partition_name_format_is_custom] || @config[:archive_partition_name_format]
+      return true if child_table == Naming.rebalance_staging_partition_name(@table_name)
+
+      strategy = (@strategy ||= Strategy.for(@config))
+      return true if strategy.respond_to?(:tail_slot_name?) && strategy.tail_slot_name?(child_table)
+
+      !strategy.archive_bucket_from_partition_name(child_table).nil?
+    rescue Date::Error
+      false
+    end
+
     def compute_horizon_days(partitions)
       today = PartitionGardener.configuration.today
       finite_ends = partitions.filter_map do |partition|

data/lib/partition_gardener/child_column_align.rb

@@ -0,0 +1,165 @@
+module PartitionGardener
+  class ChildColumnAlign
+    Column = Data.define(
+      :name,
+      :type,
+      :not_null,
+      :default_expression,
+      :collation_schema,
+      :collation_name
+    )
+
+    def self.lagging_child_warnings(parent_table, connection: Connection.connection, candidate_table: nil)
+      new(connection: connection).lagging_child_warnings(parent_table, candidate_table: candidate_table)
+    end
+
+    def initialize(connection: Connection.connection)
+      @connection = connection
+    end
+
+    def align!(parent_table, child_table)
+      missing = missing_ordinary_columns(parent_table, child_table)
+      add_columns!(child_table, missing) if missing.any?
+    end
+
+    def lagging_child_warnings(parent_table, candidate_table: nil)
+      child_tables = unattached_child_tables(parent_table)
+      child_tables.select!(&candidate_table) if candidate_table
+      columns_by_table = ordinary_columns_by_table([parent_table, *child_tables])
+      parent_columns = columns_by_table.fetch(parent_table, [])
+
+      child_tables.filter_map do |child_table|
+        missing = missing_columns(parent_columns, columns_by_table.fetch(child_table, []))
+        next if missing.empty?
+
+        missing_columns_warning(child_table, parent_table, missing)
+      end
+    end
+
+    def missing_ordinary_columns(parent_table, child_table)
+      columns_by_table = ordinary_columns_by_table([parent_table, child_table])
+      missing_columns(
+        columns_by_table.fetch(parent_table, []),
+        columns_by_table.fetch(child_table, [])
+      )
+    end
+
+    private
+
+    def add_columns!(child_table, columns)
+      actions = columns.map { |column| add_column_action(column) }.join(",\n  ")
+      @connection.execute(<<~SQL)
+        ALTER TABLE #{quoted_table(child_table)}
+          #{actions}
+      SQL
+    end
+
+    def add_column_action(column)
+      clauses = ["ADD COLUMN #{quoted_column(column.name)} #{column.type}"]
+      if column.collation_name
+        clauses << "COLLATE #{quoted_column(column.collation_schema)}.#{quoted_column(column.collation_name)}"
+      end
+      clauses << "DEFAULT #{column.default_expression}" if usable_default?(column.default_expression)
+      clauses << "NOT NULL" if column.not_null
+      clauses.join(" ")
+    end
+
+    def ordinary_columns_by_table(table_names)
+      names = table_names.uniq
+      quoted_names = names.map { |table_name| @connection.quote(table_name) }.join(", ")
+      sql = <<~SQL
+        SELECT
+          table_class.relname AS table_name,
+          attribute.attname AS name,
+          pg_catalog.format_type(attribute.atttypid, attribute.atttypmod) AS type,
+          attribute.attnotnull AS not_null,
+          pg_get_expr(column_default.adbin, column_default.adrelid) AS default_expression,
+          attribute.attidentity AS identity,
+          attribute.attgenerated AS generated,
+          collation_namespace.nspname AS collation_schema,
+          column_collation.collname AS collation_name
+        FROM pg_attribute attribute
+        LEFT JOIN pg_attrdef column_default
+          ON column_default.adrelid = attribute.attrelid
+          AND column_default.adnum = attribute.attnum
+        JOIN pg_class table_class ON table_class.oid = attribute.attrelid
+        JOIN pg_namespace table_namespace ON table_namespace.oid = table_class.relnamespace
+        JOIN pg_type attribute_type ON attribute_type.oid = attribute.atttypid
+        LEFT JOIN pg_collation column_collation
+          ON column_collation.oid = attribute.attcollation
+          AND attribute.attcollation <> attribute_type.typcollation
+        LEFT JOIN pg_namespace collation_namespace
+          ON collation_namespace.oid = column_collation.collnamespace
+        WHERE table_namespace.nspname = #{@connection.quote(schema_name)}
+          AND table_class.relname IN (#{quoted_names})
+          AND attribute.attnum > 0
+          AND NOT attribute.attisdropped
+        ORDER BY table_class.relname, attribute.attnum
+      SQL
+      @connection.execute(sql).each_with_object({}) do |row, columns_by_table|
+        next if Blank.present?(row["identity"]) || Blank.present?(row["generated"])
+
+        column = Column.new(
+          name: row["name"],
+          type: row["type"],
+          not_null: flag?(row["not_null"]),
+          default_expression: row["default_expression"],
+          collation_schema: row["collation_schema"],
+          collation_name: row["collation_name"]
+        )
+        (columns_by_table[row["table_name"]] ||= []) << column
+      end
+    end
+
+    def missing_columns(parent_columns, child_columns)
+      child_names = child_columns.to_h { |column| [column.name, true] }
+      parent_columns.reject { |column| child_names.key?(column.name) }
+    end
+
+    def unattached_child_tables(parent_table)
+      sql = <<~SQL
+        SELECT child.relname
+        FROM pg_class child
+        JOIN pg_namespace child_namespace ON child_namespace.oid = child.relnamespace
+        WHERE child_namespace.nspname = #{@connection.quote(schema_name)}
+          AND child.relkind = 'r'
+          AND starts_with(child.relname, #{@connection.quote("#{parent_table}_")})
+          AND NOT EXISTS (
+            SELECT 1
+            FROM pg_inherits inheritance
+            WHERE inheritance.inhrelid = child.oid
+          )
+        ORDER BY child.relname
+      SQL
+      @connection.execute(sql).map { |row| row["relname"] }
+    end
+
+    def missing_columns_warning(child_table, parent_table, missing)
+      names = missing.map(&:name).join(", ")
+      noun = (missing.size == 1) ? "column" : "columns"
+      "child #{child_table} is missing #{noun} #{names} from parent #{parent_table}"
+    end
+
+    def usable_default?(expression)
+      return false if Blank.blank?(expression)
+
+      !expression.strip.match?(/\ANULL(::[\w.]+)?\z/i)
+    end
+
+    def flag?(value)
+      value == true || value.to_s == "t" || value.to_s == "true"
+    end
+
+    def quoted_table(name)
+      @connection.quote_table_name(name)
+    end
+
+    def quoted_column(name)
+      @connection.quote_column_name(name)
+    end
+
+    def schema_name
+      PartitionGardener.configuration.schema_name
+    end
+  end
+end

data/lib/partition_gardener/config_document.rb

@@ -22,6 +22,7 @@ module PartitionGardener
       retention_apply
       retention_keep_table
       retention_detach_concurrently
+      align_child_columns
       hash_modulus
       maintenance_backend
       incremental_rebalance
@@ -173,6 +174,7 @@ module PartitionGardener
       validate_registry_conflict_key!(document)
       validate_registry_optional_bucket!(document)
       validate_registry_optional_maintenance_backend!(document)
+      validate_registry_optional_boolean!(document, "align_child_columns")
       document
     end
 
@@ -233,6 +235,13 @@ module PartitionGardener
       raise ArgumentError, "maintenance_backend must be gardener, pg_partman, or hybrid_layout_only"
     end
 
+    def validate_registry_optional_boolean!(document, key)
+      return unless document.key?(key)
+      return if document.fetch(key) == true || document.fetch(key) == false
+
+      raise ArgumentError, "#{key} must be true or false"
+    end
+
     def register_validated_document!(document)
       Registry.register(from_hash(validate_registry_document!(document)))
     end

data/lib/partition_gardener/configuration.rb

@@ -11,6 +11,7 @@ module PartitionGardener
       :incremental_rebalance,
       :run_record_enabled,
       :retention_detach_concurrently,
+      :align_child_columns,
       :strict_maintenance_backend_validation,
       :current_run_metrics
 
@@ -29,6 +30,7 @@ module PartitionGardener
       @run_record_enabled = true
       @run_record_store = nil
       @retention_detach_concurrently = false
+      @align_child_columns = true
       @strict_maintenance_backend_validation = false
       @current_run_metrics = nil
     end

data/lib/partition_gardener/date_bucket.rb

@@ -101,7 +101,7 @@ module PartitionGardener
         match = partition_name.match(/^#{Regexp.escape(table_name)}_(\d{4})$/)
         return Date.new(match[1].to_i, 1, 1) if match
       else
-        match = partition_name.match(/^#{Regexp.escape(table_name)}_(\d{4})_(\d{2})$/)
+        match = partition_name.match(/^#{Regexp.escape(table_name)}_(\d{4})_(\d{2})(?:_01)?$/)
         return Date.new(match[1].to_i, match[2].to_i, 1) if match
       end
 

data/lib/partition_gardener/executor.rb

@@ -5,16 +5,26 @@ module PartitionGardener
     def self.for_config(config, connection: Connection.connection)
       new(
         connection: connection,
-        batch_size: config.fetch(:move_batch_size, MOVE_BATCH_SIZE)
+        batch_size: config.fetch(:move_batch_size, MOVE_BATCH_SIZE),
+        align_child_columns: config.fetch(
+          :align_child_columns,
+          PartitionGardener.configuration.align_child_columns
+        )
       )
     end
 
-    def initialize(connection: Connection.connection, batch_size: MOVE_BATCH_SIZE)
+    def initialize(
+      connection: Connection.connection,
+      batch_size: MOVE_BATCH_SIZE,
+      align_child_columns: PartitionGardener.configuration.align_child_columns
+    )
       @connection = connection
       @batch_size = batch_size
+      @align_child_columns = align_child_columns
     end
 
     def attach_partition(table_name, partition_name, for_values_clause)
+      align_child_columns!(table_name, partition_name)
       sql = <<~SQL
         ALTER TABLE #{quoted_table(table_name)} ATTACH PARTITION #{quoted_table(partition_name)}
         FOR VALUES #{for_values_clause}
@@ -23,6 +33,7 @@ module PartitionGardener
     end
 
     def attach_default_partition(table_name, partition_name)
+      align_child_columns!(table_name, partition_name)
       sql = <<~SQL
         ALTER TABLE #{quoted_table(table_name)} ATTACH PARTITION #{quoted_table(partition_name)} DEFAULT
       SQL
@@ -59,6 +70,7 @@ module PartitionGardener
         )
       SQL
       @connection.execute(sql)
+      align_child_columns!(table_name, partition_name)
 
       conflict_columns = conflict_key.map { |column| @connection.quote_column_name(column) }.join(", ")
       sql = <<~SQL
@@ -141,6 +153,12 @@ module PartitionGardener
 
     private
 
+    def align_child_columns!(parent_table, child_table)
+      return unless @align_child_columns
+
+      ChildColumnAlign.new(connection: @connection).align!(parent_table, child_table)
+    end
+
     def quoted_table(name)
       @connection.quote_table_name(name)
     end

data/lib/partition_gardener/layout/calendar_year.rb

@@ -8,7 +8,7 @@ module PartitionGardener
           DateCalendar.add_years(active_start, active_years)
         end
 
-        def build_segments(config:, active_start:, active_end:, hot_years:)
+        def build_segments(config:, active_start:, active_end:, hot_years:, occupied_segments: [])
           strategy = Strategy::DateRange.new(config.merge(bucket: :year))
           buckets = strategy.send(:each_bucket_in_range, active_start, active_end)
 
@@ -19,7 +19,8 @@ module PartitionGardener
             active_start: active_start,
             active_end: active_end,
             hot_bucket_name: config[:partition_name_format],
-            bucket_end: ->(bucket) { DateCalendar.beginning_of_year(DateCalendar.next_year(bucket)) }
+            bucket_end: ->(bucket) { DateCalendar.beginning_of_year(DateCalendar.next_year(bucket)) },
+            occupied_segments: occupied_segments
           )
         end
       end

data/lib/partition_gardener/layout/occupied_window.rb

@@ -0,0 +1,86 @@
+module PartitionGardener
+  module Layout
+    module OccupiedWindow
+      module_function
+
+      def plan_segments(config:, window:, hot_buckets:, year_bucket:, tail_slot:)
+        occupied_segments = segments(table_name: config[:table_name], window: window, tail_slot: tail_slot)
+        layout_kwargs = {
+          config: config,
+          active_start: window[:start],
+          active_end: window[:end],
+          occupied_segments: occupied_segments
+        }
+
+        if year_bucket
+          CalendarYear.build_segments(**layout_kwargs, hot_years: hot_buckets)
+        else
+          SlidingWindow.build_segments(**layout_kwargs, hot_months: hot_buckets)
+        end
+      end
+
+      def segments(table_name:, window:, tail_slot:)
+        Connection.attached_partitions(table_name).filter_map do |partition|
+          next if partition.default
+          next if tail_slot.call(partition.name)
+          next unless overlap?(partition, window)
+
+          Plan::Segment.new(
+            name: partition.name,
+            range_start: partition.range_start,
+            range_end: partition.range_end,
+            kind: :hot_bucket
+          )
+        end.sort_by(&:range_start)
+      end
+
+      def overlap?(partition, window)
+        return false unless partition.range_start.is_a?(Date)
+        return false if partition.range_end.nil?
+        return true if partition.range_end == :max
+        return true if partition.range_end > window[:end]
+
+        partition.range_start < window[:end] && partition.range_end > window[:start]
+      end
+
+      def covering(occupied_segments, bucket)
+        occupied_segments.find do |segment|
+          next false if segment.range_start > bucket
+
+          segment.range_end == :max || segment.range_end > bucket
+        end
+      end
+
+      def next_bucket_index(buckets, bound, from:)
+        return buckets.length if bound == :max
+
+        index = from
+        index += 1 while index < buckets.length && buckets[index] < bound
+        index
+      end
+
+      def finish_with_high_end(segments, occupied_segments:, table_name:, active_end:)
+        leftover = occupied_segments.reject { |occupant| segments.any? { |segment| segment.name == occupant.name } }
+        leftover.each { |occupant| segments << occupant }
+
+        return segments if occupied_segments.any? { |segment| segment.range_end == :max }
+
+        segments << Plan::Segment.new(
+          name: Naming.future_partition_name(table_name),
+          range_start: future_start(occupied_segments, active_end),
+          range_end: :max,
+          kind: :future
+        )
+        segments
+      end
+
+      def future_start(occupied_segments, active_end)
+        later_ends = occupied_segments.filter_map do |segment|
+          segment.range_end if segment.range_end.is_a?(Date) && segment.range_end > active_end
+        end
+
+        [active_end, *later_ends].max
+      end
+    end
+  end
+end

data/lib/partition_gardener/layout/sliding_window.rb

@@ -7,7 +7,7 @@ module PartitionGardener
           DateBucket.add_buckets(active_start, span, bucket)
         end
 
-        def build_segments(config:, active_start:, active_end:, hot_months:)
+        def build_segments(config:, active_start:, active_end:, hot_months:, occupied_segments: [])
           strategy = Strategy::DateRange.new(config)
           buckets = strategy.send(:each_bucket_in_range, active_start, active_end)
           bucket = config.fetch(:bucket, :month)
@@ -19,7 +19,8 @@ module PartitionGardener
             active_start: active_start,
             active_end: active_end,
             hot_bucket_name: config[:partition_name_format],
-            bucket_end: ->(bucket_start) { DateBucket.end_of_bucket(bucket_start, bucket) }
+            bucket_end: ->(bucket_start) { DateBucket.end_of_bucket(bucket_start, bucket) },
+            occupied_segments: occupied_segments
           )
         end
       end

data/lib/partition_gardener/layout/zone_segments.rb

@@ -3,7 +3,7 @@ module PartitionGardener
     module ZoneSegments
       module_function
 
-      def build_filler_and_hot_segments(table_name:, buckets:, hot_buckets:, active_start:, active_end:, hot_bucket_name:, bucket_end:)
+      def build_filler_and_hot_segments(table_name:, buckets:, hot_buckets:, active_start:, active_end:, hot_bucket_name:, bucket_end:, occupied_segments: [])
         hot_bucket_set = hot_buckets.to_set
         segments = []
         middle_filler_index = 0
@@ -11,6 +11,13 @@ module PartitionGardener
 
         while index < buckets.length
           bucket = buckets[index]
+          occupant = OccupiedWindow.covering(occupied_segments, bucket)
+
+          if occupant
+            segments << occupant unless segments.any? { |segment| segment.name == occupant.name }
+            index = OccupiedWindow.next_bucket_index(buckets, occupant.range_end, from: index)
+            next
+          end
 
           if hot_bucket_set.include?(bucket)
             segments << Plan::Segment.new(
@@ -24,7 +31,7 @@ module PartitionGardener
           end
 
           run_start = bucket
-          while index < buckets.length && !hot_bucket_set.include?(buckets[index])
+          while index < buckets.length && !hot_bucket_set.include?(buckets[index]) && OccupiedWindow.covering(occupied_segments, buckets[index]).nil?
             index += 1
           end
           run_end = (index < buckets.length) ? buckets[index] : active_end
@@ -48,14 +55,12 @@ module PartitionGardener
           )
         end
 
-        segments << Plan::Segment.new(
-          name: Naming.future_partition_name(table_name),
-          range_start: active_end,
-          range_end: :max,
-          kind: :future
+        OccupiedWindow.finish_with_high_end(
+          segments,
+          occupied_segments: occupied_segments,
+          table_name: table_name,
+          active_end: active_end
         )
-
-        segments
       end
     end
   end

data/lib/partition_gardener/strategy/date_range.rb

@@ -25,22 +25,13 @@ module PartitionGardener
         window = active_window
         heatmap = collect_heatmap(window)
         hot_buckets = hot_buckets_in_window(heatmap, window)
-
-        segments = if year_bucket?
-          Layout::CalendarYear.build_segments(
-            config: @config,
-            active_start: window[:start],
-            active_end: window[:end],
-            hot_years: hot_buckets
-          )
-        else
-          Layout::SlidingWindow.build_segments(
-            config: @config,
-            active_start: window[:start],
-            active_end: window[:end],
-            hot_months: hot_buckets
-          )
-        end
+        segments = Layout::OccupiedWindow.plan_segments(
+          config: @config,
+          window: window,
+          hot_buckets: hot_buckets,
+          year_bucket: year_bucket?,
+          tail_slot: method(:tail_slot_name?)
+        )
 
         Plan::Result.new(segments: segments, hot_buckets: hot_buckets)
       end
@@ -231,6 +222,9 @@ module PartitionGardener
       def managed_tail_partition?(partition_name, window:)
         return true if tail_slot_name?(partition_name)
 
+        partition = Connection.attached_partitions(table_name).find { |item| item.name == partition_name }
+        return true if partition && Layout::OccupiedWindow.overlap?(partition, window)
+
         bucket = archive_bucket_from_partition_name(partition_name)
         bucket && bucket_in_window?(bucket, window)
       end

data/lib/partition_gardener/templates.rb

@@ -4,6 +4,9 @@ module PartitionGardener
 
     def normalize(config)
       config = config.dup
+      unless config.key?(:partition_name_format_is_custom)
+        config[:partition_name_format_is_custom] = config.key?(:partition_name_format)
+      end
       config[:layout] ||= :sliding_window
       config[:bucket] ||= :month if date_layout?(config[:layout])
       config
@@ -106,6 +109,7 @@ module PartitionGardener
         conflict_key: conflict_key,
         premake_months: premake_months,
         maintenance_backend: options.fetch(:maintenance_backend, :gardener),
+        partition_name_format_is_custom: options.key?(:partition_name_format),
         partition_name_format: options.fetch(:partition_name_format) {
           ->(identifier) { DateBucket.partition_name(table_name, identifier, :month) }
         },
@@ -128,6 +132,7 @@ module PartitionGardener
         partition_key_column: partition_key_column,
         conflict_key: conflict_key,
         active_years: active_years,
+        partition_name_format_is_custom: options.key?(:partition_name_format),
         partition_name_format: options.fetch(:partition_name_format) {
           ->(identifier) { DateBucket.partition_name(table_name, identifier, :year) }
         },
@@ -301,6 +306,7 @@ module PartitionGardener
         :partition_key_column => partition_key_column,
         :conflict_key => conflict_key,
         active_key => active_value,
+        :partition_name_format_is_custom => options.key?(:partition_name_format),
         :partition_name_format => options.fetch(:partition_name_format) {
           ->(identifier) { DateBucket.partition_name(table_name, identifier, bucket) }
         },

data/lib/partition_gardener/version.rb

@@ -1,3 +1,3 @@
 module PartitionGardener
-  VERSION = "0.3.3"
+  VERSION = "0.3.5"
 end

data/lib/partition_gardener.rb

@@ -14,6 +14,7 @@ require_relative "partition_gardener/configuration"
 require_relative "partition_gardener/naming"
 require_relative "partition_gardener/plan"
 require_relative "partition_gardener/connection"
+require_relative "partition_gardener/child_column_align"
 require_relative "partition_gardener/executor"
 require_relative "partition_gardener/default_partition"
 require_relative "partition_gardener/strategy/requires_default_partition"
@@ -25,6 +26,7 @@ require_relative "partition_gardener/strategy/list_split"
 require_relative "partition_gardener/strategy/composite"
 require_relative "partition_gardener/strategy"
 require_relative "partition_gardener/layout/three_area"
+require_relative "partition_gardener/layout/occupied_window"
 require_relative "partition_gardener/layout/zone_segments"
 require_relative "partition_gardener/layout/sliding_window"
 require_relative "partition_gardener/layout/calendar_year"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: partition_gardener
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors:
 - Andrei Makarov
@@ -303,6 +303,7 @@ files:
 - lib/partition_gardener/archive_retention.rb
 - lib/partition_gardener/audit.rb
 - lib/partition_gardener/blank.rb
+- lib/partition_gardener/child_column_align.rb
 - lib/partition_gardener/cli.rb
 - lib/partition_gardener/config_document.rb
 - lib/partition_gardener/configuration.rb
@@ -316,6 +317,7 @@ files:
 - lib/partition_gardener/hash_routing.rb
 - lib/partition_gardener/layout/calendar_year.rb
 - lib/partition_gardener/layout/integer_window.rb
+- lib/partition_gardener/layout/occupied_window.rb
 - lib/partition_gardener/layout/sliding_window.rb
 - lib/partition_gardener/layout/three_area.rb
 - lib/partition_gardener/layout/zone_segments.rb