code0-zero_track 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ba30f4224e83da8ce5d9c86233ccd8bec8f480636f50306bb5f786b5875867d
-  data.tar.gz: a47c562d06286ebd35c977e4825af11cf4de5d87c5339d15a4047d57ad0b7b4b
+  metadata.gz: d6150c745af141848ee0848ec9beda4db5c1809ece022f90b9006cf69df88f10
+  data.tar.gz: 73128d1d5ab33dec7887b195831c8a1b591eb46999c5cb4e20eb79387d5d138e
 SHA512:
-  metadata.gz: 8318133e64d693242f17415dda6aae7d70bcc0e27533a2f6ba67a5ca2547568770038ba2f0638dc7cbec73cf9e1e175948219c1315424921191d41165c98ac63
-  data.tar.gz: 90bb401d956616f4c6f5979073dbbdf4b8c97dcbd0b55aa53aebf1ab48ec99d4cba72c9ca4e878efc77391819ff5040767fab34b3513122e764eeec3e39eceba
+  metadata.gz: 129416f538b904432c213a42a22d95244220fb9c35548b089d9a9ef4836b11b1b3fd0a93c910ab748dfd51d024d56d00ac525e7fd22855330916462b848a3824
+  data.tar.gz: 78bba0f4d37e6a08b2d5b02a46478060e7ea944ee8a40c407a4f63c819c450ae41e86b33df9b47a28472ebb202dad28a49c2c95fa221de041d672de1164e8a6d

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2023-2026 Code0 UG (haftungsbeschränkt) i.G.
+Copyright 2023-2026 Code0 UG (haftungsbeschränkt)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

data/README.md

@@ -65,4 +65,131 @@ can be filled with the correct entries when the schema is loaded from the schema
 
 This approach is prone to git conflicts, so you can switch to a file based persistence
 with `config.zero_track.active_record.schema_migrations = true`. Instead of an `INSERT INTO` in
-the `db/structure.sql`, this mode creates files in the `db/schema_migrations` directory.
+the `db/structure.sql`, this mode creates files in the `db/schema_migrations` directory.
+
+### Table Partitioning
+
+PostgreSQL supports declarative table partitioning. The partition manager automates the
+management of partitions without manual operations or extensions on the PostgreSQL server.
+
+#### Configuration
+
+```ruby
+config.zero_track.db_partitioning.dynamic_partition_schema = 'partitions_dynamic' # default
+config.zero_track.db_partitioning.base_ar_class = 'ActiveRecord::Base' # default
+```
+
+- `dynamic_partition_schema`: The PostgreSQL schema where dynamic partitions are stored.
+- `base_ar_class`: The ActiveRecord base class used for the internal partitioning models.
+
+#### Migration Helpers
+
+Include the migration helpers by inheriting from `Code0::ZeroTrack::Database::Migration[1.0]` (or the
+appropriate version). The following methods become available:
+
+`create_partition_by_date_table(table_name, partition_column:, **options, &block)` creates a table
+partitioned by range on the given column. It automatically sets up a composite primary key
+of `(id, partition_column)`.
+
+`create_dynamic_partition_schema` / `drop_dynamic_partition_schema` creates or drops the schema
+used for storing dynamic partitions.
+
+`create_partitioning_views` / `drop_partitioning_views` creates or drops the PostgreSQL views
+(`postgres_partitioned_tables`, `postgres_partitions`, `postgres_detached_partitions`) that the
+partition manager uses to inspect existing partitions.
+
+Example migration:
+
+```ruby
+class CreatePartitionedEvents < Code0::ZeroTrack::Database::Migration[1.0]
+  def change
+    create_dynamic_partition_schema
+    create_partitioning_views
+
+    create_partition_by_date_table :events, partition_column: :created_at do |t|
+      t.text :name, null: false
+      t.timestamps_with_timezone null: false
+    end
+  end
+end
+```
+
+The schema and views only need to be created once before creating the first partitioned table.
+
+Tables don't necessarily have to be created with the provided helper. The partition manager will
+work as long as the model is correctly configured.
+
+#### Defining a Partitioned Model
+
+Include `Code0::ZeroTrack::Database::Partitioning::PartitionedTable` in your model and declare
+the partitioning strategy:
+
+```ruby
+class Event < ApplicationRecord
+  include Code0::ZeroTrack::Database::Partitioning::PartitionedTable
+
+  partition_by :created_at, strategy: :monthly, retain_for: 12.months
+end
+```
+
+Available strategies: `:daily` and `:monthly`.
+
+Options passed to `partition_by`:
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `strategy` | `:daily` or `:monthly` | *required* |
+| `headroom` | How far ahead to pre-create partitions | 30 days (daily) / 6 months (monthly) |
+| `retain_for` | How long to keep partitions before detaching (enables retention) | `nil` (disabled) |
+| `retain_detached_for` | How long to keep detached partitions before dropping | 7 days |
+
+#### Partition Manager
+
+Register models for automatic partition management:
+
+```ruby
+Code0::ZeroTrack::Database::Partitioning::PartitionManager.register_model(Event)
+Code0::ZeroTrack::Database::Partitioning::PartitionManager.register_model(EventDetail)
+```
+
+Then synchronize all registered models. The gem won't run this for you.
+Call it from a cron job, Sidekiq scheduler, or deploy script:
+
+```ruby
+Code0::ZeroTrack::Database::Partitioning::PartitionManager.sync_all_partitions!
+```
+
+Or manage a single model:
+
+```ruby
+manager = Code0::ZeroTrack::Database::Partitioning::PartitionManager.new(Event)
+manager.sync_partitions!
+```
+
+`sync_all_partitions!` first creates partitions for all registered models, then detaches and drops
+partitions for all models in reverse registration order.
+
+`sync_partitions!` performs three operations in order for a single model:
+1. Create and attach new partitions to cover the desired range (up to the configured headroom).
+2. Detach partitions that fall outside the desired range (when retention is enabled).
+3. Drop detached partitions that have been detached longer than `retain_detached_for`.
+
+If needed, the three phases can be called individually with `create_partitions!`, `detach_partitions!`
+and `drop_partitions!`. This only works on a partition manager for a specific model. There is no
+shortcut to run this on all registered models like the `sync_all_partitions!` method.
+
+Each table gets a PostgreSQL advisory lock, so concurrent calls won't conflict.
+
+When tables have foreign key relationships, registration order and retention configuration matter:
+
+- Register parent tables before child tables. `sync_all_partitions!` creates partitions in
+  registration order and detaches/drops them in reverse order. This way the parent tables
+  are created before the children and dropped after their children.
+- A child table's `retain_for` must be less than or equal to the parent table's `retain_for`.
+  If a child retains partitions longer than its parent, dropping the parent partition will
+  fail because the child's foreign key still references it.
+
+#### Schema Cleaner Integration
+
+Dynamic partition tables are automatically removed from `db/structure.sql` if the
+[schema cleaner](#configzero_trackactive_recordschema_cleaner) is enabled.

data/lib/code0/zero_track/database/migration.rb

@@ -11,6 +11,7 @@ module Code0
           include Database::MigrationHelpers::IndexHelpers
           include Database::MigrationHelpers::RemoveColumnEnhancements
           include Database::MigrationHelpers::TableEnhancements
+          include Database::MigrationHelpers::TablePartitioning
         end
         # rubocop:enable Naming/ClassAndModuleCamelCase
 

data/lib/code0/zero_track/database/migration_helpers/table_partitioning.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module MigrationHelpers
+        module TablePartitioning
+          def create_partition_by_date_table(table_name, partition_column:, **options, &block)
+            options[:options] = "PARTITION BY RANGE (#{quote_column_name(partition_column)})"
+            options[:id] = false
+
+            create_table(table_name, **options) do |t|
+              t.bigserial :id, null: false
+
+              block.call(t)
+            end
+
+            reversible do |dir|
+              dir.up do
+                execute <<~SQL.squish
+                  ALTER TABLE #{quote_table_name(table_name)}
+                  ADD PRIMARY KEY (#{quote_column_name(:id)}, #{quote_column_name(partition_column)})
+                SQL
+              end
+            end
+          end
+
+          def create_dynamic_partition_schema
+            schema = quote_table_name(Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema)
+            execute "CREATE SCHEMA #{schema}"
+          end
+
+          def drop_dynamic_partition_schema
+            schema = quote_table_name(Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema)
+            execute "DROP SCHEMA #{schema}"
+          end
+
+          def create_partitioning_views
+            dynamic_schema = Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema
+
+            execute <<-SQL.squish
+              CREATE OR REPLACE VIEW postgres_partitioned_tables AS
+              SELECT c.oid::regclass::text AS identifier,
+                     c.oid,
+                     n.nspname AS schema,
+                     c.relname AS name,
+                     CASE p.partstrat
+                       WHEN 'l' THEN 'list'
+                       WHEN 'r' THEN 'range'
+                       WHEN 'h' THEN 'hash'
+                     END AS strategy,
+                     pg_get_partkeydef(c.oid) AS partition_key
+              FROM pg_partitioned_table p
+              JOIN pg_class c ON c.oid = p.partrelid
+              JOIN pg_namespace n ON n.oid = c.relnamespace
+              WHERE n.nspname = current_schema();
+            SQL
+
+            execute <<-SQL.squish
+              CREATE OR REPLACE VIEW postgres_partitions AS
+              SELECT c.oid::regclass::text AS identifier,
+                     c.oid,
+                     n.nspname AS schema,
+                     c.relname AS name,
+                     i.inhparent::regclass::text AS parent_identifier,
+                     pg_get_expr(c.relpartbound, c.oid) AS condition,
+                     obj_description(c.oid) AS comment,
+                     i.inhrelid IS NOT NULL AS attached
+              FROM pg_class c
+              LEFT JOIN pg_inherits i ON c.oid = i.inhrelid
+              JOIN pg_namespace n ON n.oid = c.relnamespace
+              WHERE c.relispartition
+                AND c.relkind = 'r'
+                AND n.nspname IN (current_schema(), #{quote(dynamic_schema)});
+            SQL
+
+            execute <<-SQL.squish
+              CREATE OR REPLACE VIEW postgres_detached_partitions AS
+              SELECT c.oid::regclass::text AS identifier,
+                     c.oid,
+                     n.nspname AS schema,
+                     c.relname AS name,
+                     obj_description(c.oid)::jsonb ->> 'table' AS parent_identifier,
+                     (obj_description(c.oid)::jsonb ->> 'detached_at')::timestamptz AS detached_at
+              FROM pg_class c
+              JOIN pg_namespace n ON n.oid = c.relnamespace
+              WHERE c.relkind = 'r'
+                AND n.nspname = #{quote(dynamic_schema)}
+                AND NOT EXISTS (
+                  SELECT 1 FROM pg_inherits WHERE inhrelid = c.oid
+                )
+                AND obj_description(c.oid)::jsonb ? 'table'
+                AND obj_description(c.oid)::jsonb ? 'detached_at';
+            SQL
+          end
+
+          def drop_partitioning_views
+            execute 'DROP VIEW IF EXISTS postgres_detached_partitions'
+            execute 'DROP VIEW IF EXISTS postgres_partitions'
+            execute 'DROP VIEW IF EXISTS postgres_partitioned_tables'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/partition_manager.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        class PartitionManager
+          include Loggable
+
+          cattr_accessor :models
+          self.models = []
+
+          def self.register_model(clazz)
+            models << clazz
+          end
+
+          def self.reset_registered_models!
+            models.clear
+          end
+
+          def self.sync_all_partitions!
+            models.each do |model|
+              new(model).create_partitions!
+            end
+
+            models.reverse_each do |model|
+              manager = new(model)
+              manager.detach_partitions!
+              manager.drop_partitions!
+            end
+          end
+
+          attr_reader :model
+
+          def initialize(model)
+            if model.try(:partitioning_strategy).nil?
+              raise ArgumentError, "Model #{model} not configured for partitioning"
+            end
+
+            @model = model
+          end
+
+          def sync_partitions!
+            create_partitions!
+
+            detach_partitions!
+
+            drop_partitions!
+          end
+
+          def create_partitions!
+            with_lock do |connection|
+              model.partitioning_strategy.partitions_to_create.each do |partition|
+                create_partition(partition, connection)
+                attach_partition(partition, connection)
+              end
+            end
+          end
+
+          def detach_partitions!
+            with_lock do |connection|
+              model.partitioning_strategy.partitions_to_detach.each do |partition|
+                detach_partition(partition, connection)
+              end
+            end
+          end
+
+          def drop_partitions!
+            with_lock do |connection|
+              model.partitioning_strategy.partitions_to_drop.each do |detached_partition|
+                drop_partition(detached_partition, connection)
+              end
+            end
+          end
+
+          private
+
+          def create_partition(partition, connection)
+            connection.execute(partition.to_create_sql(connection))
+            logger.info(
+              message: 'Created new partition',
+              table_name: partition.model.table_name,
+              partition_name: partition.partition_name
+            )
+          end
+
+          def attach_partition(partition, connection)
+            connection.execute(partition.to_attach_sql(connection))
+            logger.info(
+              message: 'Attached partition',
+              table_name: partition.model.table_name,
+              partition_name: partition.partition_name
+            )
+          end
+
+          def detach_partition(partition, connection)
+            connection.execute(partition.to_detach_sql(connection))
+
+            partition_comment = connection.quote({ table: model.table_name, detached_at: Time.current.iso8601 }.to_json)
+            fully_qualified_partition = partition.fully_qualified_partition(connection)
+            connection.execute("COMMENT ON TABLE #{fully_qualified_partition} IS #{partition_comment}")
+
+            logger.info(
+              message: 'Detached partition',
+              table_name: partition.model.table_name,
+              partition_name: partition.partition_name
+            )
+          end
+
+          def drop_partition(detached_partition, connection)
+            schema_name = connection.quote_table_name(detached_partition.schema)
+            partition_name = connection.quote_table_name(detached_partition.name)
+            qualified_name = "#{schema_name}.#{partition_name}"
+            connection.execute("DROP TABLE #{qualified_name}")
+
+            logger.info(
+              message: 'Dropped partition',
+              table_name: detached_partition.parent_identifier,
+              partition_name: detached_partition.name
+            )
+          end
+
+          def with_lock
+            lock_key = lock_key_for(model.table_name)
+
+            with_connection do |connection|
+              connection.transaction do
+                connection.execute("SELECT pg_advisory_xact_lock(#{lock_key})")
+                yield connection
+              end
+            end
+          end
+
+          def lock_key_for(table_name)
+            namespace = 'zero_track:partition_sync'
+            Zlib.crc32("#{namespace}:#{table_name}")
+          end
+
+          def with_connection(&block)
+            model.with_connection(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/partitioned_table.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        module PartitionedTable
+          extend ActiveSupport::Concern
+
+          PARTITIONING_STRATEGIES = {
+            daily: Partitioning::Strategy::Daily,
+            monthly: Partitioning::Strategy::Monthly,
+          }.freeze
+
+          class_methods do
+            attr_reader :partitioning_strategy
+
+            def partition_by(column, strategy:, **kwargs)
+              raise(ArgumentError, 'Table is already partitioned') unless partitioning_strategy.nil?
+
+              strategy_class = PARTITIONING_STRATEGIES[strategy] || raise(
+                ArgumentError,
+                "Unknown partitioning strategy: #{strategy}"
+              )
+
+              @partitioning_strategy = strategy_class.new(self, column, **kwargs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/postgres_detached_partition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        class PostgresDetachedPartition < Rails.application.config.zero_track.db_partitioning.base_ar_class.constantize
+          self.table_name = 'postgres_detached_partitions'
+          self.primary_key = 'identifier'
+
+          def readonly?
+            true
+          end
+
+          scope :detached_before, ->(timestamp) { where(detached_at: ..timestamp) }
+
+          belongs_to :postgres_partitioned_table,
+                     class_name: 'Code0::ZeroTrack::Database::Partitioning::PostgresPartitionedTable',
+                     foreign_key: 'parent_identifier',
+                     primary_key: 'identifier',
+                     inverse_of: :postgres_detached_partitions
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/postgres_partition.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        class PostgresPartition < Rails.application.config.zero_track.db_partitioning.base_ar_class.constantize
+          self.table_name = 'postgres_partitions'
+          self.primary_key = 'identifier'
+
+          def readonly?
+            true
+          end
+
+          belongs_to :postgres_partitioned_table,
+                     class_name: 'Code0::ZeroTrack::Database::Partitioning::PostgresPartitionedTable',
+                     foreign_key: 'parent_identifier',
+                     primary_key: 'identifier',
+                     inverse_of: :postgres_partitions
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/postgres_partitioned_table.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        class PostgresPartitionedTable < Rails.application.config.zero_track.db_partitioning.base_ar_class.constantize
+          self.table_name = 'postgres_partitioned_tables'
+          self.primary_key = 'identifier'
+
+          def readonly?
+            true
+          end
+
+          has_many :postgres_partitions,
+                   class_name: 'Code0::ZeroTrack::Database::Partitioning::PostgresPartition',
+                   foreign_key: 'parent_identifier',
+                   primary_key: 'identifier',
+                   inverse_of: :postgres_partitioned_table
+
+          has_many :postgres_detached_partitions,
+                   class_name: 'Code0::ZeroTrack::Database::Partitioning::PostgresDetachedPartition',
+                   foreign_key: 'parent_identifier',
+                   primary_key: 'identifier',
+                   inverse_of: :postgres_partitioned_table
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/strategy/base.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        module Strategy
+          class Base
+            attr_reader :model, :partitioning_column, :headroom, :retain_for, :retain_detached_for
+
+            def initialize(
+              model,
+              partitioning_column,
+              headroom: default_headroom,
+              retain_for: nil,
+              retain_detached_for: 7.days
+            )
+              @model = model
+              @partitioning_column = partitioning_column
+              @headroom = headroom
+              @retain_for = retain_for
+              @retain_detached_for = retain_detached_for
+            end
+
+            def current_partitions
+              raise NotImplementedError
+            end
+
+            def desired_partitions
+              raise NotImplementedError
+            end
+
+            def oldest_active_date
+              raise NotImplementedError
+            end
+
+            def partition_name(lower_bound)
+              raise NotImplementedError
+            end
+
+            def default_headroom
+              raise NotImplementedError
+            end
+
+            def partitions_to_create
+              desired_partitions - current_partitions
+            end
+
+            def partitions_to_detach
+              current_partitions - desired_partitions
+            end
+
+            def partitions_to_drop
+              partitioned_table = PostgresPartitionedTable.find_by(identifier: model.table_name)
+
+              if partitioned_table.nil?
+                logger.warn(message: 'Failed to find partitioned table', identifier: model.table_name)
+                return []
+              end
+
+              partitioned_table.postgres_detached_partitions.detached_before(retain_detached_for.ago)
+            end
+
+            def retention_enabled?
+              retain_for.present?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/strategy/daily.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        module Strategy
+          class Daily < Time
+            PARTITION_SUFFIX = 'Y%YM%mD%d'
+
+            def advance_date(date)
+              date + 1.day
+            end
+
+            def normalize_date(date)
+              date.beginning_of_day.to_date
+            end
+
+            def partition_name(lower_bound)
+              suffix = lower_bound&.strftime(PARTITION_SUFFIX) || 'Y0000M00D00'
+
+              "#{model.table_name}_#{suffix}"
+            end
+
+            def default_headroom
+              30.days
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/strategy/monthly.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        module Strategy
+          class Monthly < Time
+            PARTITION_SUFFIX = 'Y%YM%m'
+
+            def advance_date(date)
+              date.next_month
+            end
+
+            def normalize_date(date)
+              date.beginning_of_month.to_date
+            end
+
+            def partition_name(lower_bound)
+              suffix = lower_bound&.strftime(PARTITION_SUFFIX) || 'Y0000M00'
+
+              "#{model.table_name}_#{suffix}"
+            end
+
+            def default_headroom
+              6.months
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/strategy/time.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        module Strategy
+          class Time < Base
+            include Loggable
+
+            def current_partitions
+              partitioned_table = PostgresPartitionedTable.find_by(identifier: model.table_name)
+
+              if partitioned_table.nil?
+                logger.warn(message: 'Failed to find partitioned table', identifier: model.table_name)
+                return []
+              end
+
+              partitioned_table.postgres_partitions.map do |partition|
+                TimePartition.from_sql(model, partition.name, partition.condition)
+              end
+            end
+
+            def desired_partitions
+              partitions = []
+
+              min_date, max_date = desired_range
+
+              while min_date < max_date
+                next_date = advance_date(min_date)
+
+                partitions << TimePartition.new(
+                  model,
+                  min_date,
+                  next_date,
+                  partition_name: partition_name(min_date)
+                )
+
+                min_date = next_date
+              end
+
+              partitions
+            end
+
+            def desired_range
+              if retention_enabled?
+                min_date = oldest_active_date
+              else
+                first_partition = current_partitions.min
+
+                min_date = first_partition.from || first_partition.to if first_partition
+                min_date ||= Date.current
+              end
+
+              min_date = normalize_date(min_date)
+
+              max_date = advance_date(Date.current) + headroom
+
+              [min_date, max_date]
+            end
+
+            def oldest_active_date
+              normalize_date(retain_for.ago)
+            end
+
+            def advance_date(date)
+              raise NotImplementedError
+            end
+
+            def normalize_date(date)
+              raise NotImplementedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/partitioning/time_partition.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        class TimePartition
+          include Comparable
+
+          def self.from_sql(table, partition_name, definition)
+            matches = definition.match(/FOR VALUES FROM \('?(?<from>[^)']+)'?\) TO \('?(?<to>[^)']+)'?\)/)
+
+            raise ArgumentError, "Unknown partition definition: #{definition}" unless matches
+
+            raise NotImplementedError, 'MAXVALUE as upper bound is not supported' if matches[:to] == 'MAXVALUE'
+
+            from = matches[:from] == 'MINVALUE' ? nil : matches[:from]
+            to = matches[:to]
+
+            new(table, from, to, partition_name: partition_name)
+          end
+
+          attr_reader :model, :from, :to, :partition_name
+
+          def initialize(model, from, to, partition_name:)
+            @model = model
+            @from = date_or_nil(from)
+            @to = date_or_nil(to)
+            @partition_name = partition_name
+          end
+
+          def ==(other)
+            model == other.model && partition_name == other.partition_name && from == other.from && to == other.to
+          end
+          alias eql? ==
+
+          def hash
+            [model, partition_name, from, to].hash
+          end
+
+          def <=>(other)
+            return if model != other.model
+
+            partition_name <=> other.partition_name
+          end
+
+          def to_create_sql(connection)
+            <<~SQL.squish
+              CREATE TABLE IF NOT EXISTS #{fully_qualified_partition(connection)}
+              (LIKE #{connection.quote_table_name(model.table_name)} INCLUDING ALL)
+            SQL
+          end
+
+          def to_attach_sql(connection)
+            from_sql = from ? connection.quote(from.to_date.iso8601) : 'MINVALUE'
+            to_sql = connection.quote(to.to_date.iso8601)
+
+            <<~SQL.squish
+              ALTER TABLE #{connection.quote_table_name(model.table_name)}
+              ATTACH PARTITION #{fully_qualified_partition(connection)}
+              FOR VALUES FROM (#{from_sql}) TO (#{to_sql})
+            SQL
+          end
+
+          def to_detach_sql(connection)
+            <<~SQL.squish
+              ALTER TABLE #{connection.quote_table_name(model.table_name)}
+              DETACH PARTITION #{fully_qualified_partition(connection)}
+            SQL
+          end
+
+          def fully_qualified_partition(connection)
+            format(
+              '%<schema>s.%<partition>s',
+              schema: connection.quote_table_name(
+                Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema
+              ),
+              partition: connection.quote_table_name(partition_name)
+            )
+          end
+
+          private
+
+          def date_or_nil(obj)
+            return unless obj
+            return obj if obj.is_a?(Date)
+
+            Date.parse(obj)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/schema_cleaner.rb

@@ -38,6 +38,10 @@ module Code0
             'CREATE EXTENSION IF NOT EXISTS \1;'
           )
 
+          # Remove dynamic partition objects that are managed automatically at runtime.
+          # These would cause schema drift on every partition rotation if left in the dump.
+          remove_dynamic_partitions!(structure)
+
           structure.gsub!(/\n{3,}/, "\n\n")
 
           io << structure.strip
@@ -45,6 +49,31 @@ module Code0
 
           nil
         end
+
+        private
+
+        def dynamic_partition_schema
+          Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema
+        end
+
+        def remove_dynamic_partitions!(structure)
+          schema = Regexp.escape(dynamic_partition_schema)
+
+          # Remove CREATE TABLE <schema>.<partition> (...);
+          structure.gsub!(/^CREATE TABLE #{schema}\.\S+\s*\(.*?\);\n/m, '')
+
+          # Remove ALTER TABLE ... ATTACH PARTITION <schema>.<partition> ...;
+          structure.gsub!(/^ALTER TABLE .+ ATTACH PARTITION #{schema}\.\S+.*?;\n/, '')
+
+          # Remove ALTER TABLE ONLY <schema>.<partition> ...;
+          structure.gsub!(/^ALTER TABLE ONLY #{schema}\.\S+\n.*?;\n/m, '')
+
+          # Remove CREATE [UNIQUE] INDEX ... ON <schema>.<partition> ...;
+          structure.gsub!(/^CREATE (?:UNIQUE )?INDEX \S+ ON #{schema}\.\S+.*?;\n/m, '')
+
+          # Remove ALTER INDEX ... ATTACH PARTITION <schema>.<partition>;
+          structure.gsub!(/^ALTER INDEX \S+ ATTACH PARTITION #{schema}\.\S+;\n/, '')
+        end
       end
     end
   end

data/lib/code0/zero_track/railtie.rb

@@ -4,11 +4,16 @@ module Code0
   module ZeroTrack
     class Railtie < ::Rails::Railtie
       config.zero_track = ActiveSupport::OrderedOptions.new
+
       config.zero_track.active_record = ActiveSupport::OrderedOptions.new
       config.zero_track.active_record.timestamps = false
       config.zero_track.active_record.schema_migrations = false
       config.zero_track.active_record.schema_cleaner = false
 
+      config.zero_track.db_partitioning = ActiveSupport::OrderedOptions.new
+      config.zero_track.db_partitioning.dynamic_partition_schema = 'partitions_dynamic'
+      config.zero_track.db_partitioning.base_ar_class = 'ActiveRecord::Base'
+
       rake_tasks do
         path = File.expand_path(__dir__)
         Dir.glob("#{path}/../../tasks/**/*.rake").each { |f| load f }

data/lib/code0/zero_track/version.rb

@@ -2,6 +2,6 @@
 
 module Code0
   module ZeroTrack
-    VERSION = '0.0.7'
+    VERSION = '0.0.8'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code0-zero_track
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Niklas van Schrick
@@ -167,6 +167,17 @@ files:
 - lib/code0/zero_track/database/migration_helpers/index_helpers.rb
 - lib/code0/zero_track/database/migration_helpers/remove_column_enhancements.rb
 - lib/code0/zero_track/database/migration_helpers/table_enhancements.rb
+- lib/code0/zero_track/database/migration_helpers/table_partitioning.rb
+- lib/code0/zero_track/database/partitioning/partition_manager.rb
+- lib/code0/zero_track/database/partitioning/partitioned_table.rb
+- lib/code0/zero_track/database/partitioning/postgres_detached_partition.rb
+- lib/code0/zero_track/database/partitioning/postgres_partition.rb
+- lib/code0/zero_track/database/partitioning/postgres_partitioned_table.rb
+- lib/code0/zero_track/database/partitioning/strategy/base.rb
+- lib/code0/zero_track/database/partitioning/strategy/daily.rb
+- lib/code0/zero_track/database/partitioning/strategy/monthly.rb
+- lib/code0/zero_track/database/partitioning/strategy/time.rb
+- lib/code0/zero_track/database/partitioning/time_partition.rb
 - lib/code0/zero_track/database/postgresql_adapter/dump_schema_versions_mixin.rb
 - lib/code0/zero_track/database/postgresql_database_tasks/load_schema_versions_mixin.rb
 - lib/code0/zero_track/database/schema_cleaner.rb