schema_reaper 2.0.0 → 2.1.0

data/lib/schema_reaper/inflect.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SchemaReaper
+  # Just enough of ActiveSupport's inflector to map model class names to
+  # table names without depending on it. A wrong guess only weakens a
+  # heuristic -- it never makes a finding more confident.
+  module Inflect
+    module_function
+
+    def underscore(str)
+      str.gsub(/([A-Z\d]+)([A-Z][a-z])/, '\\1_\\2').gsub(/([a-z\d])([A-Z])/, '\\1_\\2').downcase
+    end
+
+    def pluralize(word)
+      case word
+      when /[^aeiou]y\z/ then word.sub(/y\z/, "ies")
+      when /(s|x|z|ch|sh)\z/ then "#{word}es"
+      else "#{word}s"
+      end
+    end
+
+    def singularize(word)
+      case word
+      when /ies\z/ then word.sub(/ies\z/, "y")
+      when /(ss|sh|ch|x|z)es\z/ then word.sub(/es\z/, "")
+      when /s\z/ then word.sub(/s\z/, "")
+      else word
+      end
+    end
+
+    # User -> users, LineItem -> line_items, Address -> addresses
+    def tableize(class_name)
+      pluralize(underscore(class_name))
+    end
+  end
+end

data/lib/schema_reaper/introspect/postgres.rb

@@ -1,7 +1,18 @@
 # frozen_string_literal: true
 
 module SchemaReaper
+  # Reads a live database's schema and statistics. PostgreSQL only for now.
   module Introspect
+    # `pg` is deliberately not a runtime dependency -- the host app already
+    # bundles its own (every Rails + PostgreSQL app does), and pinning a second
+    # version here would fight it. Without this rescue a missing gem surfaces
+    # as a baffling NameError instead.
+    def self.require_pg!
+      require "pg"
+    rescue LoadError
+      raise Error, "schema_reaper needs the `pg` gem to talk to PostgreSQL -- add `gem \"pg\"` to your Gemfile"
+    end
+
     # Reads live schema + planner statistics from PostgreSQL using the `pg` gem
     # directly, so the host app does not need to boot Rails.
     class Postgres
@@ -21,24 +32,68 @@ module SchemaReaper
       # expression itself contains: COALESCE(a, b), ROUND(x, 2), etc.
       COLUMN_SEPARATOR = 31.chr
 
-      def initialize(url)
-        require "pg" # load first so the PG::Error rescue below can resolve
+      # Ceiling of each integer column type, for the sequence-exhaustion check:
+      # a bigint sequence feeding an integer column overflows at the column's
+      # limit, not the sequence's.
+      TYPE_MAX = {
+        "smallint" => 32_767, "integer" => 2_147_483_647, "bigint" => 9_223_372_036_854_775_807
+      }.freeze
+
+      # Tables in `public` keep their bare name, so every existing config,
+      # baseline and finding id stays valid; tables in any other scanned schema
+      # are reported as `schema.table`.
+      def self.display_name(namespace, table)
+        namespace == "public" ? table : "#{namespace}.#{table}"
+      end
+
+      def initialize(url, schemas: Config::DEFAULTS["schemas"])
+        Introspect.require_pg!
         raise Error, NO_URL if url.nil? || url.empty?
 
-        @conn = PG.connect(url)
-      rescue PG::Error => e
-        raise Error, "could not connect to the database: #{e.message.strip}"
+        @schemas = Array(schemas)
+        @conn = connect(url)
       end
 
       def call
         DatabaseSchema.new(
-          tables: table_names.map { |n| build_table(n) },
-          index_scan_total: index_scan_total
+          tables: table_refs.map { |ns, name| build_table(ns, name) },
+          index_scan_total: index_scan_total,
+          sequences: sequences
         )
       end
 
+      # Health facts for `schema_reaper doctor`, separate from #call so a scan
+      # never pays for them.
+      def diagnostics
+        {
+          server_version: exec("SHOW server_version").first&.fetch("server_version"),
+          stats_reset: exec(<<~SQL).first&.fetch("stats_reset"),
+            SELECT stats_reset FROM pg_stat_database WHERE datname = current_database()
+          SQL
+          never_analyzed: never_analyzed,
+          in_recovery: exec("SELECT pg_is_in_recovery() AS r").first&.fetch("r") == "t"
+        }
+      end
+
       private
 
+      def never_analyzed
+        exec(<<~SQL, [pg_array(@schemas)]).map { |r| self.class.display_name(r["schemaname"], r["relname"]) }
+          SELECT schemaname, relname FROM pg_stat_user_tables
+          WHERE schemaname = ANY($1::text[]) AND last_analyze IS NULL AND last_autoanalyze IS NULL
+          ORDER BY schemaname, relname
+        SQL
+      end
+
+      # Kept out of #initialize: a `rescue PG::Error` there is evaluated for
+      # *any* exception, including require_pg!'s, and would itself raise NameError
+      # when pg is the thing that failed to load.
+      def connect(url)
+        PG.connect(url)
+      rescue PG::Error => e
+        raise Error, "could not connect to the database: #{e.message.strip}"
+      end
+
       # Cluster-wide cumulative index scans. Lets the unused-index analyzer tell
       # "this index is never used" apart from "this database has no query
       # history", which look identical at the level of a single idx_scan = 0.
@@ -47,29 +102,39 @@ module SchemaReaper
           .first&.fetch("total")&.to_i
       end
 
-      def table_names
-        exec(<<~SQL).map { |r| r["tablename"] }
-          SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename
+      # Partitions are left out: the app (and every analyzer) deals with the
+      # partitioned parent, so reporting `events_2026_01` as an unreferenced
+      # table would be wrong. The parent's row count and index usage are
+      # rolled up from its partitions instead.
+      def table_refs
+        exec(<<~SQL, [pg_array(@schemas)]).map { |r| [r["schemaname"], r["tablename"]] }
+          SELECT n.nspname AS schemaname, c.relname AS tablename
+          FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE c.relkind IN ('r', 'p') AND NOT c.relispartition AND n.nspname = ANY($1::text[])
+          ORDER BY n.nspname = 'public' DESC, n.nspname, c.relname
         SQL
       end
 
-      def build_table(name)
+      def build_table(namespace, name)
+        fks = foreign_key_constraints_for(namespace, name)
         Table.new(
-          name: name,
-          columns: columns_for(name),
-          indexes: indexes_for(name),
-          primary_key: primary_key_for(name),
-          foreign_keys: foreign_keys_for(name),
-          row_count: row_count_for(name)
+          name: self.class.display_name(namespace, name),
+          columns: columns_for(namespace, name),
+          indexes: indexes_for(namespace, name),
+          primary_key: primary_key_for(namespace, name),
+          foreign_keys: fks.flat_map(&:columns).uniq,
+          foreign_key_constraints: fks,
+          row_count: row_count_for(namespace, name)
         )
       end
 
-      def columns_for(table)
-        stats = column_stats_for(table)
-        exec(<<~SQL, [table]).map do |r|
+      def columns_for(namespace, table)
+        stats = column_stats_for(namespace, table)
+        exec(<<~SQL, [namespace, table]).map do |r|
           SELECT column_name, data_type, is_nullable, column_default
           FROM information_schema.columns
-          WHERE table_schema = 'public' AND table_name = $1
+          WHERE table_schema = $1 AND table_name = $2
           ORDER BY ordinal_position
         SQL
           s = stats[r["column_name"]] || {}
@@ -78,37 +143,60 @@ module SchemaReaper
             sql_type: r["data_type"],
             null: r["is_nullable"] == "YES",
             default: r["column_default"],
-            bytes: AVG_TYPE_BYTES.fetch(r["data_type"], 16),
+            bytes: measured_bytes(s) || AVG_TYPE_BYTES.fetch(r["data_type"], 16),
             null_fraction: s[:null_frac],
             distinct_values: s[:n_distinct]
           )
         end
       end
 
+      # avg_width covers non-null values only, and a NULL takes no space in
+      # the row (just its bit in the null bitmap), so scale by the share of
+      # rows that actually hold a value.
+      def measured_bytes(stats)
+        return 0 if stats[:null_frac].to_f >= 1.0 # all NULL: only the null-bitmap bit, avg_width 0
+        return nil unless stats[:avg_width]
+
+        (stats[:avg_width] * (1.0 - stats[:null_frac].to_f)).round
+      end
+
       # pg_stats.n_distinct: >= 0 is an absolute count, < 0 is a ratio of rows.
-      def column_stats_for(table)
-        exec(<<~SQL, [table]).each_with_object({}) do |r, h|
-          SELECT attname, null_frac, n_distinct
-          FROM pg_stats WHERE schemaname = 'public' AND tablename = $1
+      # avg_width is the measured average stored width of the non-null values,
+      # far closer to reality than a per-type guess for text/jsonb/arrays.
+      def column_stats_for(namespace, table)
+        exec(<<~SQL, [namespace, table]).each_with_object({}) do |r, h|
+          SELECT attname, null_frac, n_distinct, avg_width
+          FROM pg_stats WHERE schemaname = $1 AND tablename = $2
+          -- later rows win below: a plain row (inherited = false) beats an inherited one, and a
+          -- partitioned parent, which only has inherited rows, still gets those
+          ORDER BY inherited DESC
         SQL
           nd = r["n_distinct"].to_f
+          width = r["avg_width"]&.to_i
           h[r["attname"]] = {
             null_frac: r["null_frac"].to_f,
-            n_distinct: nd >= 0 ? nd.round : nil
+            n_distinct: nd >= 0 ? nd.round : nil,
+            avg_width: width&.positive? ? width : nil
           }
         end
       end
 
+      # A partitioned parent's index (relkind 'I') is never scanned itself --
+      # the planner scans each partition's index -- so its usage is the sum
+      # over the leaf partitions, or every such index would look unused.
+      #
       # Columns come back in index-key order via pg_get_indexdef(indexrelid,
       # column_no, pretty), keyed by column position rather than table attnum
       # so it renders a plain column and an expression uniformly and never
       # silently drops one. indnkeyatts excludes INCLUDE columns, which are
       # payload only. partial (indpred IS NOT NULL) lets analyzers refuse to
       # treat a conditional index as if it covered every row.
-      def indexes_for(table)
-        exec(<<~SQL, [table]).map do |r|
-          SELECT i.relname AS name, ix.indisunique AS "unique", ix.indisprimary AS "primary",
-                 (ix.indpred IS NOT NULL) AS partial, s.idx_scan AS scans,
+      def indexes_for(namespace, table)
+        exec(<<~SQL, [namespace, table]).map do |r|
+          SELECT i.relname AS name, (i.relkind = 'I') AS partitioned,
+                 ix.indisunique AS "unique", ix.indisprimary AS "primary",
+                 (ix.indpred IS NOT NULL) AS partial,
+                 #{partitioned_index_scans_sql} AS scans,
                  array_to_string(
                    array_agg(pg_get_indexdef(ix.indexrelid, k.ord::int, true) ORDER BY k.ord),
                    '#{COLUMN_SEPARATOR}'
@@ -118,55 +206,170 @@ module SchemaReaper
           JOIN pg_class i ON i.oid = ix.indexrelid
           JOIN LATERAL generate_series(1, ix.indnkeyatts) AS k(ord) ON TRUE
           LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.oid
-          WHERE t.relname = $1 AND t.relnamespace = 'public'::regnamespace
-          GROUP BY i.relname, ix.indisunique, ix.indisprimary, ix.indpred, s.idx_scan
+          WHERE t.relnamespace = $1::regnamespace AND t.relname = $2
+          GROUP BY i.oid, i.relname, i.relkind, ix.indisunique, ix.indisprimary, ix.indpred, s.idx_scan
         SQL
-          Index.new(
-            name: r["name"], columns: r["cols"].split(COLUMN_SEPARATOR),
-            unique: r["unique"] == "t", primary: r["primary"] == "t", partial: r["partial"] == "t",
-            scans: r["scans"]&.to_i
-          )
+          build_index(r)
         end
       end
 
+      def build_index(row)
+        Index.new(
+          name: row["name"], columns: row["cols"].split(COLUMN_SEPARATOR),
+          unique: row["unique"] == "t", primary: row["primary"] == "t", partial: row["partial"] == "t",
+          scans: row["scans"]&.to_i, partitioned: row["partitioned"] == "t"
+        )
+      end
+
       # Every primary-key column, in key order. A composite key needs the whole
       # list: returning one arbitrary column leaves the rest looking like
-      # ordinary columns to the analyzers.
-      def primary_key_for(table)
-        exec(<<~SQL, [table]).map { |r| r["attname"] }
+      # ordinary columns to the analyzers. The relation is resolved by schema
+      # and name rather than a ::regclass cast, which would follow search_path.
+      def primary_key_for(namespace, table)
+        exec(<<~SQL, [namespace, table]).map { |r| r["attname"] }
           SELECT a.attname
           FROM pg_index i
+          JOIN pg_class t ON t.oid = i.indrelid
           JOIN LATERAL unnest(i.indkey::int2[]) WITH ORDINALITY AS k(attnum, ord) ON TRUE
           JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = k.attnum
-          WHERE i.indrelid = $1::regclass AND i.indisprimary
+          WHERE t.relnamespace = $1::regnamespace AND t.relname = $2 AND i.indisprimary
           ORDER BY k.ord
         SQL
       rescue Error, PG::Error
         nil
       end
 
-      def foreign_keys_for(table)
-        exec(<<~SQL, [table]).map { |r| r["column_name"] }
-          SELECT kcu.column_name
-          FROM information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-          WHERE tc.constraint_type = 'FOREIGN KEY'
-            AND tc.table_schema = 'public' AND tc.table_name = $1
+      # Read from pg_constraint rather than information_schema: constraint
+      # names are only unique per table, so joining key_column_usage on the
+      # name alone mixes up two tables' same-named constraints. conkey keeps
+      # a composite key's columns together and in order.
+      def foreign_key_constraints_for(namespace, table)
+        exec(<<~SQL, [namespace, table]).map { |r| build_foreign_key(r) }
+          SELECT c.conname AS name,
+                 array_to_string(array_agg(a.attname ORDER BY k.ord), ',') AS cols,
+                 rn.nspname AS ref_schema, rt.relname AS ref_table,
+                 c.confkey::text AS ref_key, c.confupdtype, c.confdeltype, c.confmatchtype,
+                 c.condeferrable, c.condeferred, c.convalidated
+          FROM pg_constraint c
+          JOIN pg_class t ON t.oid = c.conrelid
+          JOIN pg_class rt ON rt.oid = c.confrelid
+          JOIN pg_namespace rn ON rn.oid = rt.relnamespace
+          JOIN LATERAL unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord) ON TRUE
+          JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum
+          WHERE c.contype = 'f' AND t.relnamespace = $1::regnamespace AND t.relname = $2
+            #{"AND c.conparentid = 0" if version_num >= 110_000}
+          GROUP BY c.conname, rn.nspname, rt.relname, c.confkey, c.confupdtype, c.confdeltype,
+                   c.confmatchtype, c.condeferrable, c.condeferred, c.convalidated
+          ORDER BY c.conname
         SQL
       end
 
+      def build_foreign_key(row)
+        ForeignKey.new(
+          name: row["name"], columns: row["cols"].split(","),
+          references: self.class.display_name(row["ref_schema"], row["ref_table"]),
+          # Everything that changes what the constraint does. Two FKs are
+          # only interchangeable when all of it matches.
+          behaviour: [row["ref_key"], row["confupdtype"], row["confdeltype"], row["confmatchtype"],
+                      row["condeferrable"], row["condeferred"]].join(":"),
+          validated: row["convalidated"] == "t"
+        )
+      end
+
       # pg_class.reltuples is an estimate maintained by ANALYZE/VACUUM. On
       # PostgreSQL 14+ it is -1 for a relation that has never been analysed,
       # which is "unknown", not "minus one row". Map anything negative to nil so
       # analyzers treat the count as unavailable.
-      def row_count_for(table)
-        raw = exec(<<~SQL, [table]).first&.fetch("reltuples")&.to_f
-          SELECT reltuples FROM pg_class WHERE relname = $1
+      # A partitioned parent holds no rows itself: sum its leaf partitions,
+      # and treat the count as unknown if any leaf is unanalysed.
+      def row_count_for(namespace, table)
+        return legacy_row_count_for(namespace, table) unless pg12?
+
+        rows = exec(<<~SQL, [namespace, table])
+          SELECT leaf.reltuples
+          FROM pg_class t
+          JOIN LATERAL (
+            SELECT c.reltuples FROM pg_partition_tree(t.oid) pt JOIN pg_class c ON c.oid = pt.relid
+            WHERE t.relkind = 'p' AND pt.isleaf
+            UNION ALL
+            SELECT t.reltuples WHERE t.relkind = 'r'
+          ) leaf ON TRUE
+          WHERE t.relnamespace = $1::regnamespace AND t.relname = $2
+        SQL
+        counts = rows.map { |r| r["reltuples"].to_f }
+        return nil if counts.empty? || counts.any?(&:negative?)
+
+        counts.sum.round
+      end
+
+      # A CYCLE sequence wraps instead of running out, and a descending one
+      # counts towards min_value, so neither is reported.
+      #
+      # Sequences owned by a column (serial, bigserial or IDENTITY), with the
+      # ceiling that actually applies: the lower of the sequence's max_value
+      # and the owning column type's. pg_sequences.last_value is NULL until
+      # the sequence has been used, and unreadable without USAGE/SELECT on it.
+      def sequences
+        exec(<<~SQL, [pg_array(@schemas)]).map { |r| build_sequence(r) }
+          SELECT s.schemaname, s.sequencename, s.last_value, s.max_value, s.min_value,
+                 tn.nspname AS table_schema, t.relname AS table_name, a.attname AS column_name,
+                 format_type(a.atttypid, NULL) AS column_type
+          FROM pg_sequences s
+          JOIN pg_class sc ON sc.relname = s.sequencename AND sc.relnamespace = s.schemaname::regnamespace
+          JOIN pg_depend d ON d.objid = sc.oid AND d.classid = 'pg_class'::regclass
+                          AND d.refclassid = 'pg_class'::regclass AND d.deptype IN ('a', 'i')
+          JOIN pg_class t ON t.oid = d.refobjid
+          JOIN pg_namespace tn ON tn.oid = t.relnamespace
+          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = d.refobjsubid
+          WHERE s.schemaname = ANY($1::text[]) AND s.last_value IS NOT NULL
+            AND NOT s.cycle AND s.increment_by > 0
+        SQL
+      rescue Error
+        [] # PG < 10 has no pg_sequences, or no privilege: skip, never fail the scan
+      end
+
+      def build_sequence(row)
+        ceiling = [row["max_value"].to_i, TYPE_MAX.fetch(row["column_type"], row["max_value"].to_i)].min
+        Sequence.new(
+          name: self.class.display_name(row["schemaname"], row["sequencename"]),
+          table: self.class.display_name(row["table_schema"], row["table_name"]),
+          column: row["column_name"], column_type: row["column_type"],
+          last_value: row["last_value"].to_i, max_value: ceiling
+        )
+      end
+
+      # PostgreSQL 10/11 lack pg_partition_tree (and 10 lacks conparentid).
+      # Both are still worth supporting; on them partitioned parents get the
+      # pre-partition-aware treatment.
+      def version_num
+        @version_num ||= exec("SHOW server_version_num").first["server_version_num"].to_i
+      end
+
+      def pg12?
+        version_num >= 120_000
+      end
+
+      def partitioned_index_scans_sql
+        return "s.idx_scan" unless pg12?
+
+        <<~SQL.strip
+          CASE WHEN i.relkind = 'I' THEN (
+            SELECT sum(cs.idx_scan) FROM pg_partition_tree(i.oid) pt
+            JOIN pg_stat_user_indexes cs ON cs.indexrelid = pt.relid
+            WHERE pt.isleaf
+          ) ELSE s.idx_scan END
+        SQL
+      end
+
+      def legacy_row_count_for(namespace, table)
+        raw = exec(<<~SQL, [namespace, table]).first&.fetch("reltuples")&.to_f
+          SELECT reltuples FROM pg_class WHERE relnamespace = $1::regnamespace AND relname = $2
         SQL
-        return nil if raw.nil? || raw.negative?
+        raw.nil? || raw.negative? ? nil : raw.round
+      end
 
-        raw.round
+      def pg_array(values)
+        PG::TextEncoder::Array.new.encode(values)
       end
 
       def exec(sql, params = nil)

data/lib/schema_reaper/migration_generator.rb

@@ -3,7 +3,9 @@
 require "fileutils"
 
 module SchemaReaper
-  # Emits a two-step, reversible migration pair for a dead column.
+  # Emits removal migrations: a two-step pair for a dead column (ignore, then
+  # drop), or a single migration for an index (index:) or a whole table (no
+  # column: and no index:).
   class MigrationGenerator
     # Enough of Rails' inflector for table names in this comment text -- a
     # wrong guess doesn't break anything functional, just reads oddly.
@@ -13,19 +15,99 @@ module SchemaReaper
       [/s\z/, ""]                   # employees  -> employee
     ].freeze
 
-    def initialize(table:, column:, dir: "db/migrate")
+    def initialize(table:, column: nil, index: nil, dir: "db/migrate")
+      raise ArgumentError, "pass column: or index:, not both" if column && index
+
       @table = table
       @column = column
+      @index = index
       @dir = dir
     end
 
     def call
       FileUtils.mkdir_p(@dir)
+      return [drop_index] if @index
+      return [drop_table] unless @column
+
       [stage_one, stage_two]
     end
 
     private
 
+    # CREATE/DROP INDEX CONCURRENTLY cannot run inside a transaction, hence
+    # disable_ddl_transaction!. A partitioned index can't be dropped
+    # concurrently at all, and the generator never sees the database, so the
+    # migration checks pg_class itself when it runs. The down raises rather
+    # than guessing at the index's definition; recreate it from db/schema.rb.
+    def drop_index
+      down_msg = "recreate #{@index} on :#{@table} from db/schema.rb if you need it back"
+      write "remove_#{@index}", <<~RUBY
+        # frozen_string_literal: true
+
+        # Removes #{@index} -- concurrently, so writes to #{@table} are not
+        # blocked, unless it is a partitioned index, which PostgreSQL can only
+        # drop with a lock on the table and every partition.
+        class Remove#{camelize(@index)} < ActiveRecord::Migration[#{migration_version}]
+          disable_ddl_transaction!
+
+          def up
+            if partitioned_index?
+              say "#{@index} is a partitioned index: dropping it without CONCURRENTLY (locks #{@table})"
+              remove_index #{@table.to_sym.inspect}, name: #{@index.to_sym.inspect}, if_exists: true
+            else
+              remove_index #{@table.to_sym.inspect}, name: #{@index.to_sym.inspect}, algorithm: :concurrently, if_exists: true
+            end
+          end
+
+          def down
+            raise ActiveRecord::IrreversibleMigration, #{down_msg.inspect}
+          end
+
+          #{partitioned_check}
+        end
+      RUBY
+    end
+
+    # The generated migration's private helper, indented to sit inside the
+    # class body (the first line lands where the template places it).
+    def partitioned_check
+      [
+        "private",
+        "",
+        "def partitioned_index?",
+        "  select_value(<<~SQL) == \"I\"",
+        "    SELECT relkind FROM pg_class WHERE oid = to_regclass(\#{connection.quote(#{qualified_index.inspect})})",
+        "  SQL",
+        "end"
+      ].map.with_index { |line, i| i.zero? || line.empty? ? line : "  #{line}" }.join("\n")
+    end
+
+    # An index lives in its table's schema; qualify it so to_regclass doesn't
+    # depend on search_path.
+    def qualified_index
+      @table.include?(".") ? "#{@table.split(".").first}.#{@index}" : @index
+    end
+
+    def drop_table
+      down_msg = "#{@table} and its rows are gone; restore from a backup if you need them back"
+      write "drop_#{@table}", <<~RUBY
+        # frozen_string_literal: true
+
+        # Drops #{@table} and every row in it. Run only after confirming no
+        # external consumer (reports, ETL, other services) reads it, and with
+        # a backup taken. Remove the #{model} model, if any, in the same deploy.
+        class Drop#{camelize(@table)}Table < ActiveRecord::Migration[#{migration_version}]
+          def up
+            drop_table #{@table.to_sym.inspect}
+          end
+
+          def down
+            raise ActiveRecord::IrreversibleMigration, #{down_msg.inspect}
+          end
+        end
+      RUBY
+    end
+
     def stage_one
       note = "Add `self.ignored_columns += %w[#{@column}]` to the #{model} model, " \
              "then deploy STEP 2 after a soak period."
@@ -67,7 +149,7 @@ module SchemaReaper
     def write(slug, body)
       @seq = (@seq || -1) + 1
       ts = (Time.now + @seq).strftime("%Y%m%d%H%M%S")
-      path = File.join(@dir, "#{ts}_#{slug}.rb")
+      path = File.join(@dir, "#{ts}_#{slug.tr(".", "_")}.rb")
       File.write(path, body)
       path
     end
@@ -81,7 +163,11 @@ module SchemaReaper
     end
 
     def camel
-      "#{@table}_#{@column}".split("_").map(&:capitalize).join
+      camelize("#{@table}_#{@column}")
+    end
+
+    def camelize(str)
+      str.split(/[_.]/).map(&:capitalize).join
     end
 
     def model