after_migrate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a04f2af70c48d8299c3c1eedce77608a6a57aca044711bbc2c0e8030299d18e3
+  data.tar.gz: d511331553aacbe753d40b2004af8d523b2c823ef4ba425f8491eb8a0336d234
+SHA512:
+  metadata.gz: c3f07535162f76e33ff8a7a399bbdee3b45d534b48a5609c600504a1f8b0e9c8d4d2e027ec653b7106c12e6663f91194370a9617912bd35860cdb77e6c451e6d
+  data.tar.gz: 8c529f7d643720957caf72ae2607055e286dbcafc7c15004a03e3908a6be9eab15c7dcc9c66b83c1b741265c70a2a1476e440846178bea2799a4884857639187

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,2 @@
+AllCops:
+  NewCops: enable

data/.ruby-version

@@ -0,0 +1 @@
+3.4.7

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 3.4.7
+before_install: gem install bundler -v 2.7.2

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2025-04-05
+
+### Added
+- **Smart table detection** – automatically identifies tables touched during migrations using `sql.active_record` events
+- **PostgreSQL support**
+    - `ANALYZE` on affected tables (default) or all tables
+    - Optional `VACUUM` via config
+- **SQLite support**
+    - `PRAGMA optimize` (SQLite 3.35+)
+    - Fallback to `VACUUM` + `ANALYZE` on older versions
+- **MySQL support** (MySQL 5.6+ / MariaDB)
+    - `ANALYZE TABLE` on affected tables
+- **Zero false positives** – bulletproof SQL parser ignores:
+    - Views, materialized views, functions
+    - Column names, joins, CTEs
+    - System schemas (`pg_catalog`, `information_schema`)
+- **Configurable via environment variables or block DSL**:
+  ```ruby
+      AfterMigrate.configure do |config|
+        config.enabled  = false # default: true
+        config.verbose  = false # default: true
+        config.vacuum   = false # default: true
+        config.analyze  = 'none' # only_affected_tables (default) or 'all_tables' or 'none'
+      end
+  ```

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in after_migrate.gemspec
+gemspec
+
+gem 'bundler', '~> 4'
+gem 'rake', '~> 13.0'
+gem 'rspec', '~> 3.0'
+gem 'rubocop', '~> 1.81'

data/README.md

@@ -0,0 +1,97 @@
+# AfterMigrate
+
+**Automatically run database maintenance after Rails migrations**
+
+`after_migrate` detects tables touched during `rails db:migrate` (or related tasks) and runs the appropriate optimizer commands:
+
+- **PostgreSQL** → `ANALYZE` (affected tables or all) + optional `VACUUM`
+- **SQLite**     → `PRAGMA optimize` (or `VACUUM` + `ANALYZE`)
+- **MySQL**      → `ANALYZE TABLE`
+
+Stale statistics and fragmentation after schema changes silently hurt query performance.  
+`after_migrate` fixes it - automatically and precisely.
+
+![after_migrate](./logo.png)
+
+> **Because every migration deserves a cleanup.**
+
+[![Gem Version](https://badge.fury.io/rb/after_migrate.svg)](https://badge.fury.io/rb/after_migrate)
+
+---
+
+## ✨ Features
+
+- Smart detection of affected tables (CREATE/ALTER/INSERT/UPDATE/DELETE/etc.)
+- Zero false positives - ignores views, columns, system tables, and complex joins
+- Configurable via environment variables or initializer block
+- Supports `db:migrate`, `db:rollback`, `db:migrate:redo`
+- No monkey-patching of ActiveRecord core classes
+- Works in development, test, CI, and production
+- Rails 7.0+ / Ruby 3.2+ only
+- Dependency-free
+
+---
+
+## 📦 Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'after_migrate'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+---
+
+## 🚀 Usage
+
+The gem activates automatically. No code required for default behavior.
+
+### Default behavior (recommended)
+
+Out of the box, it runs `ANALYZE` on **only the tables touched** during the migration (PostgreSQL default).
+
+### Configuration
+
+Create `config/initializers/after_migrate.rb`:
+
+```ruby
+AfterMigrate.configure do |config|
+  # Enable/disable the gem
+  config.enabled = true
+
+  # Log what’s happening
+  config.verbose = true
+
+  # Run VACUUM on affected tables (PostgreSQL only)
+  config.vacuum = false
+
+  # Choose ANALYZE strategy
+  # "only_affected_tables" - default, precise
+  # "all_tables"           - full database analyze
+  # "none"                 - skip ANALYZE entirely
+  config.analyze = "only_affected_tables"
+
+  # Enhance rake tasks (runs maintenance after db:migrate etc.)
+  # Set to false in test env if needed
+  config.rake_tasks_enhanced = true
+end
+```
+---
+
+## 🤝 Contributing
+
+Bug reports, feature requests, and pull requests are very welcome!
+
+https://github.com/moskvin/after_migrate
+
+---
+
+## 📝 License
+
+This project is available under the MIT License.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/after_migrate.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'after_migrate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'after_migrate'
+  spec.version       = AfterMigrate::VERSION
+  spec.authors       = ['Nikolay Moskvin']
+  spec.email         = ['nikolay.moskvin@gmail.com']
+
+  spec.summary       = 'Automatically ANALYZE and VACUUM tables touched during Rails migrations.'
+  spec.description = <<~DESC
+    Runs database maintenance (ANALYZE, VACUUM, PRAGMA optimize) on exactly the tables
+    created or modified during `rails db:migrate`. Keeps query planner statistics fresh
+    and prevents fragmentation after every schema change - automatically.
+  DESC
+  spec.homepage = 'https://github.com/moskvin/after_migrate'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/moskvin/after_migrate'
+    spec.metadata['changelog_uri'] = 'https://github.com/moskvin/after_migrate/blob/master/CHANGELOG.md'
+    spec.metadata['rubygems_mfa_required'] = 'true'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+          'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 3.2'
+
+  spec.add_dependency 'rails', '>= 7.0'
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'after_migrate'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/after_migrate/adapters/mysql.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module AfterMigrate
+  module Mysql
+    module_function
+
+    def optimize_tables(connection:, table_names:, **)
+      table_names.each do |t|
+        quoted = connection.quote_table_name(t)
+        AfterMigrate.log("ANALYZE TABLE #{quoted}")
+        connection.execute("ANALYZE TABLE #{quoted}")
+      end
+    end
+
+    def all_tables(schema: nil)
+      connection = ActiveRecord::Base.connection
+      database = schema.to_s.presence || connection.current_database
+
+      connection.select_values(<<~SQL.squish)
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = #{connection.quote(database)}
+          AND table_type = 'BASE TABLE'           -- exclude views
+          AND table_name NOT LIKE 'ar_internal_metadata'
+          AND table_name NOT LIKE 'schema_migrations'
+        ORDER BY table_name
+      SQL
+    end
+  end
+end

data/lib/after_migrate/adapters/postgresql.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module AfterMigrate
+  module Postgresql
+    module_function
+
+    def vacuum(table_name, schema: nil, verbose: true)
+      table = ActiveRecord::Base.connection.quote_table_name("#{schema}.#{table_name}")
+      query = <<~SQL.squish
+        VACUUM (#{'VERBOSE, ' if verbose}ANALYZE, INDEX_CLEANUP ON) #{table};
+      SQL
+
+      ActiveRecord::Base.connection.execute(query)
+    end
+
+    def dead_tuples(schema: nil, table: nil, sort: nil)
+      allowed_sorts = %w[schemaname relname n_dead_tup n_live_tup dead_tuple_ratio autovacuum_count]
+      sort = 'dead_tuple_ratio' unless allowed_sorts.include?(sort)
+      query = <<~SQL.squish
+        SELECT
+          schemaname,
+          relname,
+          last_vacuum,
+          last_autovacuum,
+          vacuum_count,
+          autovacuum_count,
+          n_dead_tup,
+          n_live_tup,
+          (COALESCE(n_dead_tup, 0)::numeric / GREATEST(COALESCE(n_live_tup, 0) + COALESCE(n_dead_tup, 0), 1)::numeric) AS dead_tuple_ratio
+        FROM pg_stat_all_tables
+        WHERE COALESCE(n_dead_tup, 0) > 0
+        #{"AND schemaname = #{ActiveRecord::Base.connection.quote(schema)}" if schema}
+        #{"AND relname = #{ActiveRecord::Base.connection.quote(table)}" if table}
+        ORDER BY #{sort} DESC NULLS LAST;
+      SQL
+
+      ActiveRecord::Base.connection.execute(query)
+    end
+
+    def run_vacuum(schema:)
+      tables_with_dead_tuples = dead_tuples(schema:).pluck('relname')
+      AfterMigrate.log("Vacuuming #{tables_with_dead_tuples.size} tables in schema #{schema}...")
+      tables_with_dead_tuples.each { |t| vacuum(t) }
+      tables_with_dead_tuples
+    end
+
+    def run_analyze(schema:, tables:)
+      connection = ActiveRecord::Base.connection
+      tables.each do |t|
+        table = if t.include?('.')
+                  connection.quote_table_name(t)
+                else
+                  connection.quote_table_name("#{schema}.#{t}")
+                end
+        AfterMigrate.log("ANALYZE VERBOSE #{table}")
+        connection.execute("ANALYZE#{AfterMigrate.configuration.verbose ? ' VERBOSE ' : ' '}#{table}")
+      end
+    end
+
+    def optimize_tables(table_names:, schema:, **)
+      cleaned_tables = []
+      cleaned_tables = run_vacuum(schema:) if AfterMigrate.configuration.vacuum
+
+      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'
+
+    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
+end

data/lib/after_migrate/adapters/sqlite.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module AfterMigrate
+  module Sqlite
+    module_function
+
+    def optimize_tables(connection:, **)
+      version = connection.respond_to?(:sqlite_version) ? connection.sqlite_version : '0'
+      if Gem::Version.new(version.split.first || '0') >= Gem::Version.new('3.35.0')
+        AfterMigrate.log('Running PRAGMA optimize')
+        connection.execute('PRAGMA optimize;')
+      else
+        AfterMigrate.log('Running VACUUM; ANALYZE;')
+        connection.execute('VACUUM;')
+        connection.execute('ANALYZE;')
+      end
+    end
+
+    def all_tables(**)
+      # SQLite has no concept of schema (everything is in one file)
+      # The `schema:` parameter is ignored — there's only one database
+      ActiveRecord::Base.connection.select_values(<<~SQL.squish)
+        SELECT name
+        FROM sqlite_master
+        WHERE type = 'table'
+          AND name NOT LIKE 'sqlite_%'
+          AND name NOT IN ('ar_internal_metadata', 'schema_migrations')
+        ORDER BY name
+      SQL
+    end
+  end
+end

data/lib/after_migrate/collector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module AfterMigrate
+  module Collector
+    extend self
+
+    module_function
+
+    def call(*)
+      event = ActiveSupport::Notifications::Event.new(*)
+      sql = event.payload[:sql]&.strip
+      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:)
+    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
+      when 'PostgreSQL'
+        quoted = connection.schema_search_path.split(',').first
+        quoted&.delete('"')
+      end
+    end
+  end
+end

data/lib/after_migrate/current.rb

@@ -0,0 +1,13 @@
+# 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

data/lib/after_migrate/executor.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'after_migrate/adapters/mysql'
+require 'after_migrate/adapters/postgresql'
+require 'after_migrate/adapters/sqlite'
+
+module AfterMigrate
+  module Executor
+    extend self
+
+    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?
+
+      target_tables.each do |s, tables|
+        run_optimize(schema: s, tables:)
+      end
+    ensure
+      AfterMigrate::Current.reset if reset
+    end
+
+    public :call
+
+    private
+
+    def run_optimize(schema:, tables:)
+      table_names = tables.to_a.sort
+      return if table_names.empty?
+
+      AfterMigrate.log("Migration touched #{table_names.size} table(s): #{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
+      when 'PostgreSQL'
+        AfterMigrate::Postgresql.optimize_tables(schema:, table_names:, connection:)
+      when 'SQLite'
+        AfterMigrate::Sqlite.optimize_tables(schema:, table_names:, connection:)
+      when 'Mysql2', 'Trilogy'
+        AfterMigrate::Mysql.optimize_tables(schema:, table_names:, connection:)
+      else
+        AfterMigrate.log("No maintenance implemented for #{adapter}")
+      end
+    end
+
+    def target_tables
+      case AfterMigrate.configuration.analyze
+      when 'all_tables'
+        AfterMigrate::Current.affected_tables.each_value do |schema|
+          all_tables(schema:)
+        end
+      when 'only_affected_tables'
+        AfterMigrate::Current.affected_tables
+      else
+        []
+      end
+    end
+
+    def all_tables(schema:)
+      connection = ActiveRecord::Base.connection
+      adapter = connection.adapter_name
+      case adapter
+      when 'PostgreSQL'
+        AfterMigrate::Postgresql.all_tables(schema:)
+      when 'SQLite'
+        AfterMigrate::Sqlite.all_tables(schema:)
+      when 'Mysql2', 'Trilogy'
+        AfterMigrate::Mysql.all_tables(schema:)
+      else
+        []
+      end
+    end
+  end
+end

data/lib/after_migrate/railtie.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'active_support/notifications'
+
+module AfterMigrate
+  class Railtie < ::Rails::Railtie
+    initializer 'after_migrate.subscribe' do |app|
+      next unless AfterMigrate.configuration.enabled
+
+      subscription = ActiveSupport::Notifications.subscribe 'sql.active_record' do |*args|
+        AfterMigrate::Collector.call(*args)
+      end
+
+      app.executor.to_run { ActiveSupport::Notifications.unsubscribe(subscription) }
+    end
+
+    rake_tasks do
+      %w[
+        db:migrate
+        db:migrate:up
+        db:migrate:redo
+      ].each do |task_name|
+        Rake::Task[task_name].enhance do
+          next unless AfterMigrate.configuration.enabled
+          next unless AfterMigrate.configuration.rake_tasks_enhanced
+
+          AfterMigrate::Executor.call(reset: true)
+        end
+      end
+    end
+  end
+end

data/lib/after_migrate/version.rb

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

data/lib/after_migrate.rb

@@ -0,0 +1,35 @@
+# 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
+
+    def initialize
+      @enabled = true
+      @verbose = true
+      @vacuum = true
+      @analyze = 'only_affected_tables'
+      @rake_tasks_enhanced = true
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def log(msg)
+      warn "[after_migrate] #{msg}" if AfterMigrate.configuration.verbose
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: after_migrate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nikolay Moskvin
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: |
+  Runs database maintenance (ANALYZE, VACUUM, PRAGMA optimize) on exactly the tables
+  created or modified during `rails db:migrate`. Keeps query planner statistics fresh
+  and prevents fragmentation after every schema change - automatically.
+email:
+- nikolay.moskvin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- after_migrate.gemspec
+- bin/console
+- bin/setup
+- lib/after_migrate.rb
+- lib/after_migrate/adapters/mysql.rb
+- lib/after_migrate/adapters/postgresql.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
+- logo.png
+homepage: https://github.com/moskvin/after_migrate
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/moskvin/after_migrate
+  source_code_uri: https://github.com/moskvin/after_migrate
+  changelog_uri: https://github.com/moskvin/after_migrate/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Automatically ANALYZE and VACUUM tables touched during Rails migrations.
+test_files: []