after_migrate 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a04f2af70c48d8299c3c1eedce77608a6a57aca044711bbc2c0e8030299d18e3
-  data.tar.gz: d511331553aacbe753d40b2004af8d523b2c823ef4ba425f8491eb8a0336d234
+  metadata.gz: a13db746f7bfcbcb7367f028493efd2b464e564b32f09be5debb62da1326f8bf
+  data.tar.gz: b1f0db683bb9b12ed407f14f3f1b1c0baba0a80cfd445c6182b9bd5ad7378821
 SHA512:
-  metadata.gz: c3f07535162f76e33ff8a7a399bbdee3b45d534b48a5609c600504a1f8b0e9c8d4d2e027ec653b7106c12e6663f91194370a9617912bd35860cdb77e6c451e6d
-  data.tar.gz: 8c529f7d643720957caf72ae2607055e286dbcafc7c15004a03e3908a6be9eab15c7dcc9c66b83c1b741265c70a2a1476e440846178bea2799a4884857639187
+  metadata.gz: '085b3be36d4031981294d5a5ddc929aae3d781c9d1c3d8446f4508f7c7c526064c8b6529b68237e3e3517885f22251b3db071839dae1bcdf8df654d1e79b2e70'
+  data.tar.gz: 212614cb1145bbe3f22d9b005e6524af133b5d50f659ca8da2efff0d6416efd7ff90fccf39575719d4237df08029a5dcab6b8ef8dfd5072027bce902bc2b3bd8

data/.ruby-version

@@ -1 +1 @@
-3.4.7
+3.4.9

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.0] - 2026-04-28
+
+### Added
+- `defer` configuration option (default: `true`) — when enabled, rake task enhancements only collect touched tables; they do not run maintenance automatically
+- `AfterMigrate.run!` public API to explicitly trigger maintenance on all collected tables across all schemas, then clear the store — intended to be called once after all tenant migrations complete in multi-tenant setups
+- `after_migrate:run` rake task as a convenience wrapper around `AfterMigrate.run!`
+
+### Changed
+- **Breaking**: replaced `AfterMigrate::Current` (`ActiveSupport::CurrentAttributes`) with a module-level persistent store (`Concurrent::Map`). The store accumulates touched tables across multiple rake task invocations and only resets when `AfterMigrate.run!` is called.
+- Fixed `all_tables` analyze mode - previously iterated `.each_value` (yielding `Concurrent::Set` objects) instead of schema names, producing incorrect SQL queries.
+
+### Removed
+- `AfterMigrate::Current` - no longer needed. If you referenced this class directly, use `AfterMigrate.affected_tables` instead.
+- `Executor.call(reset:)` parameter - the store is always cleared after `run!`; pass `schema:` to scope execution to a single schema.
+
 ## [0.1.0] - 2025-04-05
 
 ### Added

data/README.md

@@ -28,7 +28,6 @@ Stale statistics and fragmentation after schema changes silently hurt query perf
 - No monkey-patching of ActiveRecord core classes
 - Works in development, test, CI, and production
 - Rails 7.0+ / Ruby 3.2+ only
-- Dependency-free
 
 ---
 

data/after_migrate.gemspec

@@ -43,5 +43,6 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 3.2'
 
+  spec.add_dependency 'pg_query', '>= 6.1'
   spec.add_dependency 'rails', '>= 7.0'
 end

data/lib/after_migrate/adapters/mysql.rb

@@ -2,6 +2,8 @@
 
 module AfterMigrate
   module Mysql
+    extend Sql
+
     module_function
 
     def optimize_tables(connection:, table_names:, **)

data/lib/after_migrate/adapters/postgresql.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require 'pg_query'
+
 module AfterMigrate
   module Postgresql
+    extend Sql
+
     module_function
 
     def vacuum(table_name, schema: nil, verbose: true)
@@ -64,22 +68,26 @@ module AfterMigrate
       tables = table_names - cleaned_tables
       run_analyze(schema:, tables:)
     end
-  end
 
-  def all_tables(schema: nil)
-    connection = ActiveRecord::Base.connection
-    schema_value = schema ? schema.to_s.strip : 'public'
+    def all_tables(schema: nil)
+      connection = ActiveRecord::Base.connection
+      schema_value = schema ? schema.to_s.strip : 'public'
 
-    query = <<~SQL.squish
-      SELECT c.relname AS table_name
-      FROM pg_class c
-      JOIN pg_namespace n ON n.oid = c.relnamespace
-      WHERE n.nspname = #{connection.quote(schema_value)}
-        AND c.relkind IN ('r', 'p')        -- ordinary tables + partitioned tables
-        AND c.relispartition = FALSE      -- exclude partition child tables
-      ORDER BY table_name
-    SQL
+      query = <<~SQL.squish
+        SELECT c.relname AS table_name
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = #{connection.quote(schema_value)}
+          AND c.relkind IN ('r', 'p')        -- ordinary tables + partitioned tables
+          AND c.relispartition = FALSE      -- exclude partition child tables
+        ORDER BY table_name
+      SQL
+
+      connection.select_values(query)
+    end
 
-    connection.select_values(query)
+    def parse_tables(sql)
+      PgQuery.parse(sql).tables
+    end
   end
 end

data/lib/after_migrate/adapters/sql.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module AfterMigrate
+  module Sql
+    IDENT = /
+      (?:"[\w]+"|\w+)
+      (?:\.(?:"[\w]+"|\w+))*
+    /x
+
+    PATTERNS = {
+      update: /update\s+(?:only\s+)?(#{IDENT})(?!\()/ix,
+      insert: /insert\s+into\s+(#{IDENT})(?!\()/ix,
+      delete: /delete\s+from\s+(#{IDENT})(?!\()/ix,
+      drop_table: /drop\s+table\s+(?:if\s+exists\s+)?(#{IDENT})(?!\()/ix,
+      alter_table: /alter\s+table\s+(#{IDENT})(?!\()/ix,
+      create_table: /create\s+table\s+(?:if\s+not\s+exists\s+)?(#{IDENT})(?!\()/ix,
+      from_join: /(?:from|join)\s+(#{IDENT})(?!\()/ix
+    }.freeze
+
+    def parse_tables(sql)
+      PATTERNS.flat_map { |_, r| sql.scan(r).flatten }.uniq
+    end
+  end
+end

data/lib/after_migrate/adapters/sqlite.rb

@@ -2,6 +2,8 @@
 
 module AfterMigrate
   module Sqlite
+    extend Sql
+
     module_function
 
     def optimize_tables(connection:, **)

data/lib/after_migrate/collector.rb

@@ -12,29 +12,34 @@ module AfterMigrate
       return unless sql
       return unless sql.match?(/\A\s*(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE|RENAME\s+TABLE|TRUNCATE)/i)
 
-      table_names = sql.scan(/(?:from|join|update|into|table)\s+((?:"\w+"|\w+)(?:\.(?:"\w+"|\w+))*)/i).flatten
-      schema ||= fetch_schema
-      # AfterMigrate.log("[#{schema}] Detected change from '#{sql}' to table: #{table_names}") if table_names.present?
-      collect_tables(schema:, table_names:)
+      table_names = parse_tables(sql)
+      schema = fetch_schema
+      AfterMigrate.merge_tables(schema, table_names)
     end
 
     private
 
-    def collect_tables(schema:, table_names:)
-      return if table_names.blank?
-
-      AfterMigrate::Current.affected_tables ||= Hash.new { |h, k| h[k] = Concurrent::Set.new }
-      AfterMigrate::Current.affected_tables[schema].merge(table_names)
-    end
-
     def fetch_schema
       connection = ActiveRecord::Base.connection
-      adapter = connection.adapter_name
-      case adapter
+      case connection.adapter_name
       when 'PostgreSQL'
         quoted = connection.schema_search_path.split(',').first
         quoted&.delete('"')
       end
     end
+
+    def parse_tables(sql)
+      connection = ActiveRecord::Base.connection
+      case connection.adapter_name
+      when 'PostgreSQL'
+        AfterMigrate::Postgresql.parse_tables(sql)
+      when 'SQLite'
+        AfterMigrate::Sqlite.parse_tables(sql)
+      when 'Mysql2', 'Trilogy'
+        AfterMigrate::Mysql.parse_tables(sql)
+      else
+        AfterMigrate.log("No maintenance implemented for #{connection.adapter_name}")
+      end
+    end
   end
 end

data/lib/after_migrate/executor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'after_migrate/adapters/sql'
 require 'after_migrate/adapters/mysql'
 require 'after_migrate/adapters/postgresql'
 require 'after_migrate/adapters/sqlite'
@@ -10,16 +11,17 @@ module AfterMigrate
 
     module_function
 
-    def call(reset: true, schema: nil)
-      # AfterMigrate.log("Executing schema: #{schema} -> #{target_tables}...")
-      return if target_tables.blank?
-      return run_optimize(schema:, tables: target_tables[schema]) if schema.present?
+    def call(schema: nil)
+      tables = target_tables
+      return if tables.blank?
 
-      target_tables.each do |s, tables|
-        run_optimize(schema: s, tables:)
+      if schema.present?
+        run_optimize(schema:, tables: tables[schema]) if tables[schema].present?
+      else
+        tables.each { |s, t| run_optimize(schema: s, tables: t) }
       end
     ensure
-      AfterMigrate::Current.reset if reset
+      AfterMigrate.reset!
     end
 
     public :call
@@ -30,14 +32,13 @@ module AfterMigrate
       table_names = tables.to_a.sort
       return if table_names.empty?
 
-      AfterMigrate.log("Migration touched #{table_names.size} table(s): #{table_names.join(', ')}")
+      AfterMigrate.log("Migration touched #{table_names.size} table(s) in schema #{schema.inspect}: #{table_names.join(', ')}")
       optimize_tables(schema:, table_names:)
     end
 
     def optimize_tables(schema:, table_names:)
       connection = ActiveRecord::Base.connection
-      adapter = connection.adapter_name
-      case adapter
+      case connection.adapter_name
       when 'PostgreSQL'
         AfterMigrate::Postgresql.optimize_tables(schema:, table_names:, connection:)
       when 'SQLite'
@@ -45,27 +46,26 @@ module AfterMigrate
       when 'Mysql2', 'Trilogy'
         AfterMigrate::Mysql.optimize_tables(schema:, table_names:, connection:)
       else
-        AfterMigrate.log("No maintenance implemented for #{adapter}")
+        AfterMigrate.log("No maintenance implemented for #{connection.adapter_name}")
       end
     end
 
     def target_tables
       case AfterMigrate.configuration.analyze
       when 'all_tables'
-        AfterMigrate::Current.affected_tables.each_value do |schema|
-          all_tables(schema:)
+        AfterMigrate.affected_tables.keys.each_with_object({}) do |schema, hash|
+          hash[schema] = all_tables(schema:)
         end
       when 'only_affected_tables'
-        AfterMigrate::Current.affected_tables
+        AfterMigrate.affected_tables
       else
-        []
+        {}
       end
     end
 
     def all_tables(schema:)
       connection = ActiveRecord::Base.connection
-      adapter = connection.adapter_name
-      case adapter
+      case connection.adapter_name
       when 'PostgreSQL'
         AfterMigrate::Postgresql.all_tables(schema:)
       when 'SQLite'

data/lib/after_migrate/railtie.rb

@@ -12,6 +12,8 @@ module AfterMigrate
         AfterMigrate::Collector.call(*args)
       end
 
+      # Unsubscribe when the app starts serving requests so normal web traffic
+      # is never collected.
       app.executor.to_run { ActiveSupport::Notifications.unsubscribe(subscription) }
     end
 
@@ -24,8 +26,16 @@ module AfterMigrate
         Rake::Task[task_name].enhance do
           next unless AfterMigrate.configuration.enabled
           next unless AfterMigrate.configuration.rake_tasks_enhanced
+          next if AfterMigrate.configuration.defer
 
-          AfterMigrate::Executor.call(reset: true)
+          AfterMigrate.run!
+        end
+      end
+
+      namespace :after_migrate do
+        desc 'Run database maintenance (ANALYZE/VACUUM) on all tables collected across migrations'
+        task run: :environment do
+          AfterMigrate.run!
         end
       end
     end

data/lib/after_migrate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AfterMigrate
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/after_migrate.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 require 'after_migrate/version'
-require 'after_migrate/current'
 require 'after_migrate/collector'
 require 'after_migrate/executor'
 require 'after_migrate/railtie'
 
 module AfterMigrate
   class Configuration
-    attr_accessor :enabled, :verbose, :vacuum, :analyze, :rake_tasks_enhanced
+    attr_accessor :enabled, :verbose, :vacuum, :analyze, :rake_tasks_enhanced, :defer
 
     def initialize
       @enabled = true
@@ -16,6 +15,7 @@ module AfterMigrate
       @vacuum = true
       @analyze = 'only_affected_tables'
       @rake_tasks_enhanced = true
+      @defer = true
     end
   end
 
@@ -31,5 +31,29 @@ module AfterMigrate
     def log(msg)
       warn "[after_migrate] #{msg}" if AfterMigrate.configuration.verbose
     end
+
+    # Persistent cross-migration store: schema_name => Concurrent::Set<table_name>
+    def affected_tables
+      @affected_tables ||= Concurrent::Map.new
+    end
+
+    def merge_tables(schema, table_names)
+      return if table_names.blank?
+
+      set = affected_tables.compute_if_absent(schema) { Concurrent::Set.new }
+      set.merge(table_names)
+    end
+
+    # Trigger database maintenance on all collected tables, then clear the store.
+    # In multi-tenant setups call this once after all tenant migrations complete.
+    def run!(schema: nil)
+      return unless configuration.enabled
+
+      Executor.call(schema:)
+    end
+
+    def reset!
+      @affected_tables = nil
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: after_migrate
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Nikolay Moskvin
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg_query
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -48,9 +62,9 @@ files:
 - lib/after_migrate.rb
 - lib/after_migrate/adapters/mysql.rb
 - lib/after_migrate/adapters/postgresql.rb
+- lib/after_migrate/adapters/sql.rb
 - lib/after_migrate/adapters/sqlite.rb
 - lib/after_migrate/collector.rb
-- lib/after_migrate/current.rb
 - lib/after_migrate/executor.rb
 - lib/after_migrate/railtie.rb
 - lib/after_migrate/version.rb

data/lib/after_migrate/current.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/current_attributes'
-
-module AfterMigrate
-  class Current < ActiveSupport::CurrentAttributes
-    attribute :affected_tables
-
-    resets do
-      self.affected_tables = Hash.new { |h, k| h[k] = Concurrent::Set.new }
-    end
-  end
-end