code0-zero_track 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5af11d8b9714d7d557f46cfe5ea9dbd6702d3bc85f5aa67e9ce09e44c6963238
-  data.tar.gz: 5fc99a08521c502aec93ebe725d9c82c18d9b49e6a7120fba5127db9bb620f6b
+  metadata.gz: 03f2043062610cd62befd64e4dfc9ec9711dc2152059a167d79d35e303a52ae4
+  data.tar.gz: da719e16658fc3f52766edabd6c0295f7bfad788b727e5d19cf6825f6be2746a
 SHA512:
-  metadata.gz: fded2cb69f93aff4704e89b6c3094a0c9dd47a9891748ddd40af68e72eb2d432c150ecd62bf104cd864ceee65a5e782b3eef656fd7ac69ea338898f2cae713a7
-  data.tar.gz: db2a0b2c23fa93a22442e7f8e0c956ddae670a05bf4105c0a77ea98968c5827541b442b119331bdfb6f8b564b151ccedb9b1418cf45a8dd2fe243c7402748bb8
+  metadata.gz: 8bce9799e2716ea52eea6e84a78c404089d6a9d613ea1b6b8c93830aef30d5d33aace17627d0eaedc3eebd19c368ebbd904d79a48fc7fd9b91c4fc2bbafde6e6
+  data.tar.gz: 2c8eb1c633d91d3fd64016eb2c52ee98653152e9bda9f89f31d8932d2f02ed32799d5c1a5a6435a6aa7dffdda0d390d4f491b0bd8956ad0562c5f5b1a2f834f8

data/README.md

@@ -72,6 +72,21 @@ the `db/structure.sql`, this mode creates files in the `db/schema_migrations` di
 PostgreSQL supports declarative table partitioning. The partition manager automates the
 management of partitions without manual operations or extensions on the PostgreSQL server.
 
+Table partitioning is an optional feature which has to be explicitly required.
+There are multiple options to do this:
+
+1. Add the `require` above the application class definition in `config/application.rb`:
+
+   ```ruby
+   require 'code0/zero_track/features/database_partitioning'
+   ```
+
+2. Use the `require` option in the `Gemfile`
+
+   ```ruby
+   gem 'code0-zero_track', require: %w[code0/zero_track/features/database_partitioning]
+   ```
+
 #### Configuration
 
 ```ruby
@@ -82,31 +97,37 @@ 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.
 
+#### Schema and Views Setup
+
+The partition manager depends on a few PostgreSQL views.
+
+The migrations to create these views can be installed as following:
+
+```bash
+$ bin/rails code0_zero_track_database_partitioning:install:migrations
+$ bin/rails db:migrate
+```
+
 #### Migration Helpers
 
-Include the migration helpers by inheriting from `Code0::ZeroTrack::Database::Migration[1.0]` (or the
-appropriate version). The following methods become available:
+Include the migration helpers by inheriting from `Code0::ZeroTrack::Database::Migration[1.1]` (or the
+appropriate version). The following method becomes available:
 
 `create_partition_by_date_table(table_name, partition_column:, primary_key: nil, **options, &block)` creates a table
 partitioned by range on the given column. By default, it adds a `bigserial` id column and sets up a composite
 primary key of `(id, partition_column)`. If `primary_key` is provided (e.g. `primary_key: %i[date other_column]`),
 the id column is omitted and the given columns are used as the primary key instead.
 
-`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.
+> The schema/view helpers `create_dynamic_partition_schema`, `drop_dynamic_partition_schema`,
+> `create_partitioning_views` and `drop_partitioning_views` have been removed in migration version 1.1.
+> The schema and views no longer have to be created in your own migration with these helpers and instead
+> are created by migrations from the gem.
 
 Example migration:
 
 ```ruby
-class CreatePartitionedEvents < Code0::ZeroTrack::Database::Migration[1.0]
+class CreatePartitionedEvents < Code0::ZeroTrack::Database::Migration[1.1]
   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
@@ -115,8 +136,6 @@ class CreatePartitionedEvents < Code0::ZeroTrack::Database::Migration[1.0]
 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.
 
@@ -189,6 +208,9 @@ When tables have foreign key relationships, registration order and retention con
 - 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.
+- Foreign keys between the partitioned tables must be declared with `drop_foreign_keys_on_detach`
+  on the model. Otherwise, the foreign key of a detached partition will block detaching partitions
+  of the referenced table.
 
 #### Schema Cleaner Integration
 

data/db/migrate/database_partitioning/20261024153522_create_partitioning_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class CreatePartitioningSchema < Code0::ZeroTrack::Database::Migration[1.1]
+  def up
+    schema = quote_table_name(Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema)
+    execute "CREATE SCHEMA #{schema}"
+  end
+
+  def down
+    schema = quote_table_name(Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema)
+    execute "DROP SCHEMA #{schema}"
+  end
+end

data/db/migrate/database_partitioning/20261024153725_create_partitioning_views.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class CreatePartitioningViews < Code0::ZeroTrack::Database::Migration[1.1]
+  def up
+    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 down
+    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

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

@@ -12,6 +12,17 @@ module Code0
           include Database::MigrationHelpers::RemoveColumnEnhancements
           include Database::MigrationHelpers::TableEnhancements
           include Database::MigrationHelpers::TablePartitioning
+          include Database::MigrationHelpers::TablePartitioning::V1_0
+        end
+
+        class V1_1 < ::ActiveRecord::Migration[7.1]
+          include Database::MigrationHelpers::AddColumnEnhancements
+          include Database::MigrationHelpers::ConstraintHelpers
+          include Database::MigrationHelpers::IndexHelpers
+          include Database::MigrationHelpers::RemoveColumnEnhancements
+          include Database::MigrationHelpers::TableEnhancements
+          include Database::MigrationHelpers::TablePartitioning
+          include Database::MigrationHelpers::PolymorphicTriggerHelpers
         end
         # rubocop:enable Naming/ClassAndModuleCamelCase
 

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Code0
+  module ZeroTrack
+    module Database
+      module MigrationHelpers
+        # Helpers for managing polymorphic cleanup triggers.
+        #
+        # Rails does not enforce referential integrity for polymorphic associations, so deleting a
+        # parent record leaves orphaned child rows behind. These helpers install a PostgreSQL trigger
+        # that deletes the dependent polymorphic rows whenever a parent row is deleted.
+        module PolymorphicTriggerHelpers
+          POLYMORPHIC_CLEANUP_FUNCTION_NAME = 'delete_polymorphic_records_v1'
+          POLYMORPHIC_CLEANUP_TRANSITION_TABLE = 'old_rows'
+
+          def create_polymorphic_cleanup_trigger(table, parent_table, parent_column, parent_class)
+            create_polymorphic_cleanup_function
+
+            trigger_name = polymorphic_cleanup_trigger_name(table, parent_table, parent_column)
+
+            execute(<<~SQL) # rubocop:disable Rails/SquishedSQLHeredocs -- we want to keep the formatting
+              CREATE TRIGGER #{quote_table_name(trigger_name)}
+              AFTER DELETE ON #{quote_table_name(parent_table)}
+              REFERENCING OLD TABLE AS #{POLYMORPHIC_CLEANUP_TRANSITION_TABLE}
+              FOR EACH STATEMENT
+              EXECUTE FUNCTION #{quote_table_name(POLYMORPHIC_CLEANUP_FUNCTION_NAME)}(
+                #{quote(table.to_s)},
+                #{quote(parent_column.to_s)},
+                #{quote(parent_class.to_s)}
+              );
+            SQL
+          end
+
+          def drop_polymorphic_cleanup_trigger(table, parent_table, parent_column)
+            trigger_name = polymorphic_cleanup_trigger_name(table, parent_table, parent_column)
+
+            execute(<<~SQL.squish)
+              DROP TRIGGER IF EXISTS #{quote_table_name(trigger_name)} ON #{quote_table_name(parent_table)};
+            SQL
+          end
+
+          def create_polymorphic_cleanup_function
+            execute(<<~SQL) # rubocop:disable Rails/SquishedSQLHeredocs -- we want to keep the formatting
+              CREATE OR REPLACE FUNCTION #{quote_table_name(POLYMORPHIC_CLEANUP_FUNCTION_NAME)}()
+              RETURNS TRIGGER AS $$
+              BEGIN
+                EXECUTE format(
+                  'DELETE FROM %I WHERE %I = $1 AND %I IN (SELECT id FROM #{POLYMORPHIC_CLEANUP_TRANSITION_TABLE})',
+                  TG_ARGV[0],
+                  TG_ARGV[1] || '_type',
+                  TG_ARGV[1] || '_id'
+                ) USING TG_ARGV[2];
+                RETURN NULL;
+              END;
+              $$ LANGUAGE plpgsql;
+            SQL
+          end
+
+          # This method should only be used to clean up the function once no trigger uses it anymore.
+          def drop_polymorphic_cleanup_function
+            execute(<<~SQL.squish)
+              DROP FUNCTION IF EXISTS #{quote_table_name(POLYMORPHIC_CLEANUP_FUNCTION_NAME)}();
+            SQL
+          end
+
+          def polymorphic_cleanup_trigger_name(table, parent_table, parent_column)
+            identifier = "#{parent_table}_#{parent_column}_#{table}"
+            hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+
+            "trigger_delete_polymorphic_#{hashed_identifier}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,20 +27,21 @@ module Code0
             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
+          module V1_0 # rubocop:disable Naming/ClassAndModuleCamelCase
+            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 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
+            def create_partitioning_views
+              dynamic_schema = Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema
 
-            execute <<-SQL.squish
+              execute <<-SQL.squish
               CREATE OR REPLACE VIEW postgres_partitioned_tables AS
               SELECT c.oid::regclass::text AS identifier,
                      c.oid,
@@ -56,9 +57,9 @@ module Code0
               JOIN pg_class c ON c.oid = p.partrelid
               JOIN pg_namespace n ON n.oid = c.relnamespace
               WHERE n.nspname = current_schema();
-            SQL
+              SQL
 
-            execute <<-SQL.squish
+              execute <<-SQL.squish
               CREATE OR REPLACE VIEW postgres_partitions AS
               SELECT c.oid::regclass::text AS identifier,
                      c.oid,
@@ -74,9 +75,9 @@ module Code0
               WHERE c.relispartition
                 AND c.relkind = 'r'
                 AND n.nspname IN (current_schema(), #{quote(dynamic_schema)});
-            SQL
+              SQL
 
-            execute <<-SQL.squish
+              execute <<-SQL.squish
               CREATE OR REPLACE VIEW postgres_detached_partitions AS
               SELECT c.oid::regclass::text AS identifier,
                      c.oid,
@@ -93,13 +94,14 @@ module Code0
                 )
                 AND obj_description(c.oid)::jsonb ? 'table'
                 AND obj_description(c.oid)::jsonb ? 'detached_at';
-            SQL
-          end
+              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'
+            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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        class Engine < Rails::Engine
+          isolate_namespace Partitioning
+
+          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'
+
+          initializer 'code0-zero_track.database_partitioning.paths' do
+            paths['db/migrate'] = 'db/migrate/database_partitioning'
+          end
+
+          initializer 'code0-zero_track.database_partitioning.register_schema_cleaner' do
+            config.zero_track.active_record.schema_cleaner_callbacks << SchemaCleaner.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -64,6 +64,8 @@ module Code0
               model.partitioning_strategy.partitions_to_detach.each do |partition|
                 detach_partition(partition, connection)
               end
+
+              drop_declared_foreign_keys_from_detached_partitions(connection)
             end
           end
 
@@ -109,6 +111,73 @@ module Code0
             )
           end
 
+          def drop_declared_foreign_keys_from_detached_partitions(connection)
+            constraint_names = model.foreign_keys_to_drop_on_detach || []
+            return if constraint_names.empty?
+
+            warn_about_unknown_foreign_keys(constraint_names, connection)
+
+            detached_foreign_keys(constraint_names, connection).each do |qualified_table, constraint_name|
+              connection.execute(
+                "ALTER TABLE #{qualified_table} " \
+                "DROP CONSTRAINT #{connection.quote_column_name(constraint_name)}"
+              )
+
+              logger.info(
+                message: 'Dropped foreign key from detached partition',
+                table_name: model.table_name,
+                partition_name: qualified_table,
+                constraint_name: constraint_name
+              )
+            end
+          end
+
+          # We check the parent table because we drop the FK from the partition
+          # when detaching. A missing FK on the detached partition is an expected state
+          def warn_about_unknown_foreign_keys(constraint_names, connection)
+            existing = parent_foreign_key_names(connection)
+            unknown = constraint_names - existing
+            return if unknown.empty?
+
+            logger.warn(
+              message: 'Configured foreign keys to drop on detach do not exist on the partitioned table',
+              table_name: model.table_name,
+              constraint_names: unknown
+            )
+          end
+
+          def parent_foreign_key_names(connection)
+            connection.select_values(<<~SQL.squish)
+              SELECT con.conname
+              FROM pg_catalog.pg_constraint con
+              WHERE con.contype = 'f'
+                AND con.conrelid = #{connection.quote(model.table_name)}::regclass
+            SQL
+          end
+
+          def detached_foreign_keys(constraint_names, connection)
+            schema = Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema
+            quoted_names = constraint_names.map { |name| connection.quote(name) }.join(', ')
+
+            rows = connection.select_rows(<<~SQL.squish)
+              SELECT (quote_ident(n.nspname) || '.' || quote_ident(c.relname)) AS qualified_table,
+                     con.conname AS constraint_name
+              FROM pg_catalog.pg_constraint con
+              JOIN pg_catalog.pg_class c ON c.oid = con.conrelid
+              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+              WHERE con.contype = 'f'
+                AND con.conname IN (#{quoted_names})
+                AND n.nspname = #{connection.quote(schema)}
+                AND c.relkind = 'r'
+                AND NOT c.relispartition
+                AND NOT EXISTS (
+                  SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = c.oid
+                )
+            SQL
+
+            rows.map { |qualified_table, constraint_name| [qualified_table, constraint_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)

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

@@ -25,6 +25,16 @@ module Code0
 
               @partitioning_strategy = strategy_class.new(self, column, **kwargs)
             end
+
+            def drop_foreign_keys_on_detach(*constraint_names)
+              @foreign_keys_to_drop_on_detach ||= []
+              @foreign_keys_to_drop_on_detach.concat(constraint_names.flatten.map(&:to_s))
+              @foreign_keys_to_drop_on_detach
+            end
+
+            def foreign_keys_to_drop_on_detach
+              @foreign_keys_to_drop_on_detach || []
+            end
           end
         end
       end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+        class SchemaCleaner
+          def clean!(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/, '')
+
+            # Remove COMMENT ON TABLE <schema>.<partition> IS '<comment>';
+            structure.gsub!(/^COMMENT ON TABLE #{schema}\.\S+ IS .*;\n/, '')
+          end
+
+          private
+
+          def dynamic_partition_schema
+            Rails.application.config.zero_track.db_partitioning.dynamic_partition_schema
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -38,9 +38,9 @@ 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)
+          Rails.application.config.zero_track.active_record.schema_cleaner_callbacks.each do |cleaner|
+            cleaner.clean!(structure)
+          end
 
           structure.gsub!(/\n{3,}/, "\n\n")
 
@@ -49,31 +49,6 @@ 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/features/database_partitioning.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'code0/zero_track'
+
+loader = Zeitwerk::Loader.new
+loader.tag = 'code0-zero_track/database_partitioning'
+loader.inflector = Zeitwerk::GemInflector.new(File.join(__dir__, '../..'))
+
+module Code0
+  module ZeroTrack
+    module Database
+      module Partitioning
+      end
+    end
+  end
+end
+
+loader.push_dir(
+  File.expand_path(File.join(__dir__, '../database/partitioning')),
+  namespace: Code0::ZeroTrack::Database::Partitioning
+)
+
+loader.setup
+
+Code0::ZeroTrack::Database::Partitioning::Engine # eager load the engine

data/lib/code0/zero_track/railtie.rb

@@ -9,10 +9,7 @@ module Code0
       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'
+      config.zero_track.active_record.schema_cleaner_callbacks = []
 
       rake_tasks do
         path = File.expand_path(__dir__)

data/lib/code0/zero_track/version.rb

@@ -2,6 +2,6 @@
 
 module Code0
   module ZeroTrack
-    VERSION = '0.0.9'
+    VERSION = '0.1.0'
   end
 end

data/lib/code0/zero_track.rb

@@ -5,9 +5,16 @@ require 'rails/railtie'
 
 require 'zeitwerk'
 loader = Zeitwerk::Loader.new
-loader.tag = File.basename(__FILE__, '.rb')
+loader.tag = 'code0-zero_track'
 loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
 loader.push_dir(File.expand_path(File.join(__dir__, '..')))
+
+# ignore feature entrypoints
+loader.ignore("#{__dir__}/zero_track/features")
+
+# database partitioning is a separate feature which needs to be explicitly required
+loader.ignore("#{__dir__}/zero_track/database/partitioning")
+
 loader.setup
 
 module Code0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code0-zero_track
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Niklas van Schrick
@@ -158,6 +158,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- db/migrate/database_partitioning/20261024153522_create_partitioning_schema.rb
+- db/migrate/database_partitioning/20261024153725_create_partitioning_views.rb
 - lib/code0/zero_track.rb
 - lib/code0/zero_track/context.rb
 - lib/code0/zero_track/database/column_methods.rb
@@ -165,14 +167,17 @@ files:
 - lib/code0/zero_track/database/migration_helpers/add_column_enhancements.rb
 - lib/code0/zero_track/database/migration_helpers/constraint_helpers.rb
 - lib/code0/zero_track/database/migration_helpers/index_helpers.rb
+- lib/code0/zero_track/database/migration_helpers/polymorphic_trigger_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/engine.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/schema_cleaner.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
@@ -185,6 +190,7 @@ files:
 - lib/code0/zero_track/database/schema_migrations/context.rb
 - lib/code0/zero_track/database/schema_migrations/formatter.rb
 - lib/code0/zero_track/database/schema_migrations/migrations.rb
+- lib/code0/zero_track/features/database_partitioning.rb
 - lib/code0/zero_track/injectors/active_record_schema_migrations.rb
 - lib/code0/zero_track/injectors/active_record_timestamps.rb
 - lib/code0/zero_track/loggable.rb