actual_db_schema 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d7f7a42aa9ad38de5eeb7a64ca7a8a9117485a927d536f666aa2bf41be97b9f
-  data.tar.gz: 2236fd011c7aa72be7ffeef9d975da3bde1d6dd6844366cb458f51afa479395e
+  metadata.gz: a1fd777a52ad2881a451c80498693f36267944c4fe1c1b6796582900ce968224
+  data.tar.gz: d051372a40ec8002d72ce969f30cb93f02f09c4cd60b3c151922caa501d21687
 SHA512:
-  metadata.gz: 3ed9ec959e789377596103e2be9214d5374551bbba0ab17a037cd47bc6481f035adf1b7a24bc2254702d8a64eead1fc503ee4d2317a55596258d7284500f5fd3
-  data.tar.gz: 48fc36d62e62e810d6d1fd4c8e3b578654587ac13f9ad8e0245e3e08c5cecf1a683ae3292715b366d0d5ce5b11cebcf953963aed8460664ddd7b0af9d7f1af7b
+  metadata.gz: b6b16965816aff4dbc9b5cdaa5422a6cb89a609f577d6f5dfc4b93df541067d3d111c1d66decc489a312d4e602460b86e32036ce1c3653fdb477a5075b2fa85c
+  data.tar.gz: 6c133a90fd82909e1beaac3db9735e98b5d790315a115e190880a428a5cba37b76921549884e947cc67667be5678dd8bc4c9e9bee9fded042be466331651dc2e

data/.rubocop.yml

@@ -31,3 +31,15 @@ Metrics/ClassLength:
 
 Metrics/ModuleLength:
   Enabled: false
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+
+Metrics/PerceivedComplexity:
+  Max: 10
+
+Metrics/AbcSize:
+  Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.9.1] - 2026-02-25
+
+- Support schema diffs for `structure.sql`
+- Add an option to exclude specific databases from the gem's visibility scope
+- Fix a crash when the database is not available at application startup
+- Add instrumentation tooling to track stats about rolled-back phantom migrations
+
 ## [0.9.0] - 2026-01-27
 - Store migration files in the DB to avoid reliance on the filesystem, enabling CI/CD usage on platforms with ephemeral storage (e.g., Heroku, Docker).
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    actual_db_schema (0.9.0)
+    actual_db_schema (0.9.1)
       activerecord
       activesupport
       ast
@@ -146,7 +146,7 @@ GEM
     parser (3.2.2.4)
       ast (~> 2.4.1)
       racc
-    prism (1.8.0)
+    prism (1.9.0)
     psych (5.1.1.1)
       stringio
     racc (1.7.3)

data/README.md

@@ -230,6 +230,50 @@ Add the following line to your initializer file (`config/initializers/actual_db_
 config.auto_rollback_disabled = true
 ```
 
+## Rollback Instrumentation
+
+ActualDbSchema emits an `ActiveSupport::Notifications` event for each successful phantom rollback:
+
+- Event name: `rollback_migration.actual_db_schema`
+- Event is always emitted when a phantom rollback succeeds
+
+### Event payload
+
+| Field | Description |
+|-------|-------------|
+| `version` | Migration version that was rolled back |
+| `name` | Migration class name |
+| `database` | Current database name from Active Record config |
+| `schema` | Tenant schema name (or `nil` for default schema) |
+| `branch` | Branch associated with the migration metadata |
+| `manual_mode` | Whether rollback was run in manual mode |
+
+### Subscribing to rollback events
+
+You can subscribe to rollback events in your initializer to track statistics or perform custom actions:
+
+```ruby
+# config/initializers/actual_db_schema.rb
+ActiveSupport::Notifications.subscribe(ActualDbSchema::Instrumentation::ROLLBACK_EVENT) do |_name, _start, _finish, _id, payload|
+  ActualDbSchema::RollbackStatsRepository.record(payload)
+end
+```
+
+The `RollbackStatsRepository` persists rollback events to a database table (`actual_db_schema_rollback_events`) that is automatically excluded from schema dumps.
+
+Read aggregated stats at runtime:
+
+```ruby
+ActualDbSchema::RollbackStatsRepository.stats
+# => { total: 3, by_database: { "primary" => 3 }, by_schema: { "default" => 3 }, by_branch: { "main" => 3 } }
+
+ActualDbSchema::RollbackStatsRepository.total_rollbacks
+# => 3
+
+ActualDbSchema::RollbackStatsRepository.reset!
+# Clears all recorded stats
+```
+
 ## Automatic Phantom Migration Rollback On Branch Switch
 
 By default, the automatic rollback of migrations on branch switch is disabled. If you prefer to automatically rollback phantom migrations whenever you switch branches with `git checkout`, you can enable it in two ways:
@@ -264,6 +308,39 @@ This task will prompt you to choose one of the three options:
 
 Based on your selection, a post-checkout hook will be installed or updated in your `.git/hooks` folder.
 
+## Excluding Databases from Processing
+
+**For Rails 6.1+ applications using multiple databases** (especially with infrastructure databases like Solid Queue, Solid Cable, or Solid Cache), you can exclude specific databases from ActualDbSchema's processing to prevent connection conflicts.
+
+### Why You Might Need This
+
+Modern Rails applications often use the `connects_to` pattern for infrastructure databases. These databases maintain their own isolated connection pools, and ActualDbSchema's global connection switching can interfere with active queries. This is particularly common with:
+
+- **Solid Queue** (Rails 8 default job backend)
+- **Solid Cable** (WebSocket connections)
+- **Solid Cache** (caching infrastructure)
+
+### Method 1: Using `excluded_databases` Configuration
+
+Explicitly exclude databases by name in your initializer:
+
+```ruby
+# config/initializers/actual_db_schema.rb
+ActualDbSchema.configure do |config|
+  config.excluded_databases = [:queue, :cable, :cache]
+end
+```
+
+### Method 2: Using Environment Variable
+
+Set the environment variable `ACTUAL_DB_SCHEMA_EXCLUDED_DATABASES` with a comma-separated list:
+
+```sh
+export ACTUAL_DB_SCHEMA_EXCLUDED_DATABASES="queue,cable,cache"
+```
+
+**Note:** If both the environment variable and the configuration setting in the initializer are provided, the configuration setting takes precedence as it's applied after the default settings are loaded.
+
 ## Multi-Tenancy Support
 
 If your application leverages multiple schemas for multi-tenancy — such as those implemented by the [apartment](https://github.com/influitive/apartment) gem or similar solutions — you can configure ActualDbSchema to handle migrations across all schemas. To do so, add the following configuration to your initializer file (`config/initializers/actual_db_schema.rb`):

data/app/controllers/actual_db_schema/schema_controller.rb

@@ -11,7 +11,8 @@ module ActualDbSchema
     private
 
     helper_method def schema_diff_html
-      schema_diff = ActualDbSchema::SchemaDiffHtml.new("./db/schema.rb", "db/migrate")
+      schema_path = Rails.configuration.active_record.schema_format == :sql ? "./db/structure.sql" : "./db/schema.rb"
+      schema_diff = ActualDbSchema::SchemaDiffHtml.new(schema_path, "db/migrate")
       schema_diff.render_html(params[:table])
     end
   end

data/lib/actual_db_schema/configuration.rb

@@ -4,7 +4,7 @@ module ActualDbSchema
   # Manages the configuration settings for the gem.
   class Configuration
     attr_accessor :enabled, :auto_rollback_disabled, :ui_enabled, :git_hooks_enabled, :multi_tenant_schemas,
-                  :console_migrations_enabled, :migrated_folder, :migrations_storage
+                  :console_migrations_enabled, :migrated_folder, :migrations_storage, :excluded_databases
 
     def initialize
       apply_defaults(default_settings)
@@ -33,17 +33,44 @@ module ActualDbSchema
 
     def default_settings
       {
-        enabled: Rails.env.development?,
-        auto_rollback_disabled: ENV["ACTUAL_DB_SCHEMA_AUTO_ROLLBACK_DISABLED"].present?,
-        ui_enabled: Rails.env.development? || ENV["ACTUAL_DB_SCHEMA_UI_ENABLED"].present?,
-        git_hooks_enabled: ENV["ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED"].present?,
+        enabled: enabled_by_default?,
+        auto_rollback_disabled: env_enabled?("ACTUAL_DB_SCHEMA_AUTO_ROLLBACK_DISABLED"),
+        ui_enabled: ui_enabled_by_default?,
+        git_hooks_enabled: env_enabled?("ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED"),
         multi_tenant_schemas: nil,
-        console_migrations_enabled: ENV["ACTUAL_DB_SCHEMA_CONSOLE_MIGRATIONS_ENABLED"].present?,
+        console_migrations_enabled: env_enabled?("ACTUAL_DB_SCHEMA_CONSOLE_MIGRATIONS_ENABLED"),
         migrated_folder: ENV["ACTUAL_DB_SCHEMA_MIGRATED_FOLDER"].present?,
-        migrations_storage: ENV.fetch("ACTUAL_DB_SCHEMA_MIGRATIONS_STORAGE", "file").to_sym
+        migrations_storage: migrations_storage_from_env,
+        excluded_databases: parse_excluded_databases_env
       }
     end
 
+    def enabled_by_default?
+      Rails.env.development?
+    end
+
+    def ui_enabled_by_default?
+      Rails.env.development? || env_enabled?("ACTUAL_DB_SCHEMA_UI_ENABLED")
+    end
+
+    def env_enabled?(key)
+      ENV[key].present?
+    end
+
+    def migrations_storage_from_env
+      ENV.fetch("ACTUAL_DB_SCHEMA_MIGRATIONS_STORAGE", "file").to_sym
+    end
+
+    def parse_excluded_databases_env
+      return [] unless ENV["ACTUAL_DB_SCHEMA_EXCLUDED_DATABASES"].present?
+
+      ENV["ACTUAL_DB_SCHEMA_EXCLUDED_DATABASES"]
+        .split(",")
+        .map(&:strip)
+        .reject(&:empty?)
+        .map(&:to_sym)
+    end
+
     def apply_defaults(settings)
       settings.each do |key, value|
         instance_variable_set("@#{key}", value)

data/lib/actual_db_schema/engine.rb

@@ -15,21 +15,51 @@ module ActualDbSchema
 
     initializer "actual_db_schema.schema_dump_exclusions" do
       ActiveSupport.on_load(:active_record) do
-        table_name = ActualDbSchema::Store::DbAdapter::TABLE_NAME
+        ActualDbSchema::Engine.apply_schema_dump_exclusions
+      end
+    end
+
+    def self.apply_schema_dump_exclusions
+      ignore_schema_dump_table(ActualDbSchema::Store::DbAdapter::TABLE_NAME)
+      ignore_schema_dump_table(ActualDbSchema::RollbackStatsRepository::TABLE_NAME)
+      return unless schema_dump_flags_supported?
+      return unless schema_dump_connection_available?
+
+      apply_structure_dump_flags(ActualDbSchema::Store::DbAdapter::TABLE_NAME)
+      apply_structure_dump_flags(ActualDbSchema::RollbackStatsRepository::TABLE_NAME)
+    end
+
+    class << self
+      private
+
+      def ignore_schema_dump_table(table_name)
+        return unless defined?(ActiveRecord::SchemaDumper)
+        return unless ActiveRecord::SchemaDumper.respond_to?(:ignore_tables)
+
+        ActiveRecord::SchemaDumper.ignore_tables |= [table_name]
+      end
+
+      def schema_dump_flags_supported?
+        defined?(ActiveRecord::Tasks::DatabaseTasks) &&
+          ActiveRecord::Tasks::DatabaseTasks.respond_to?(:structure_dump_flags)
+      end
 
-        if defined?(ActiveRecord::SchemaDumper) && ActiveRecord::SchemaDumper.respond_to?(:ignore_tables)
-          ActiveRecord::SchemaDumper.ignore_tables |= [table_name]
+      # Avoid touching db config unless we explicitly use DB storage
+      # or a connection is already available.
+      def schema_dump_connection_available?
+        has_connection = begin
+          ActiveRecord::Base.connection_pool.connected?
+        rescue ActiveRecord::ConnectionNotDefined, ActiveRecord::ConnectionNotEstablished
+          false
         end
 
-        next unless defined?(ActiveRecord::Tasks::DatabaseTasks)
-        next unless ActiveRecord::Tasks::DatabaseTasks.respond_to?(:structure_dump_flags)
+        ActualDbSchema.config[:migrations_storage] == :db || has_connection
+      end
 
+      def apply_structure_dump_flags(table_name)
         flags = Array(ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags)
         adapter = ActualDbSchema.db_config[:adapter].to_s
-        database = ActualDbSchema.db_config[:database]
-        if database.nil? && ActiveRecord::Base.respond_to?(:connection_db_config)
-          database = ActiveRecord::Base.connection_db_config&.database
-        end
+        database = database_name
 
         if adapter.match?(/postgres/i)
           flag = "--exclude-table=#{table_name}*"
@@ -41,6 +71,14 @@ module ActualDbSchema
 
         ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
       end
+
+      def database_name
+        database = ActualDbSchema.db_config[:database]
+        if database.nil? && ActiveRecord::Base.respond_to?(:connection_db_config)
+          database = ActiveRecord::Base.connection_db_config&.database
+        end
+        database
+      end
     end
   end
 end

data/lib/actual_db_schema/instrumentation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  module Instrumentation
+    ROLLBACK_EVENT = "rollback.actual_db_schema"
+  end
+end

data/lib/actual_db_schema/migration_context.rb

@@ -20,11 +20,28 @@ module ActualDbSchema
     end
 
     def configs
-      # Rails < 6.0 has a Hash in configurations
-      if ActiveRecord::Base.configurations.is_a?(Hash)
-        [ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env]]
-      else
-        ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+      all_configs = if ActiveRecord::Base.configurations.is_a?(Hash)
+                      # Rails < 6.0 has a Hash in configurations
+                      [ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env]]
+                    else
+                      ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+                    end
+
+      filter_configs(all_configs)
+    end
+
+    def filter_configs(all_configs)
+      all_configs.reject do |db_config|
+        # Skip if database is in the excluded list
+        # Rails 6.0 uses spec_name, Rails 6.1+ uses name
+        db_name = if db_config.respond_to?(:name)
+                    db_config.name.to_sym
+                  elsif db_config.respond_to?(:spec_name)
+                    db_config.spec_name.to_sym
+                  else
+                    :primary
+                  end
+        ActualDbSchema.config.excluded_databases.include?(db_name)
       end
     end
 

data/lib/actual_db_schema/patches/migration_context.rb

@@ -37,7 +37,10 @@ module ActualDbSchema
           next unless status_up?(migration)
 
           show_info_for(migration, schema_name) if manual_mode
-          migrate(migration, rolled_back_migrations, schema_name) if !manual_mode || user_wants_rollback?
+          if !manual_mode || user_wants_rollback?
+            migrate(migration, rolled_back_migrations, schema_name,
+                    manual_mode: manual_mode)
+          end
         rescue StandardError => e
           handle_rollback_error(migration, e, schema_name)
         end
@@ -103,21 +106,36 @@ module ActualDbSchema
         puts File.read(migration.filename)
       end
 
-      def migrate(migration, rolled_back_migrations, schema_name = nil)
+      def migrate(migration, rolled_back_migrations, schema_name = nil, manual_mode: false)
         migration.name = extract_class_name(migration.filename)
 
+        branch = branch_for(migration.version.to_s)
         message = "[ActualDbSchema]"
         message += " #{schema_name}:" if schema_name
         message += " Rolling back phantom migration #{migration.version} #{migration.name} " \
-                   "(from branch: #{branch_for(migration.version.to_s)})"
+                   "(from branch: #{branch})"
         puts colorize(message, :gray)
 
         migrator = down_migrator_for(migration)
         migrator.extend(ActualDbSchema::Patches::Migrator)
         migrator.migrate
+        notify_rollback_migration(migration: migration, schema_name: schema_name, branch: branch,
+                                  manual_mode: manual_mode)
         rolled_back_migrations << migration
       end
 
+      def notify_rollback_migration(migration:, schema_name:, branch:, manual_mode:)
+        ActiveSupport::Notifications.instrument(
+          ActualDbSchema::Instrumentation::ROLLBACK_EVENT,
+          version: migration.version.to_s,
+          name: migration.name,
+          database: ActualDbSchema.db_config[:database],
+          schema: schema_name,
+          branch: branch,
+          manual_mode: manual_mode
+        )
+      end
+
       def extract_class_name(filename)
         content = File.read(filename)
         content.match(/^class\s+([A-Za-z0-9_]+)\s+</)[1]

data/lib/actual_db_schema/rollback_stats_repository.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  # Persists rollback events in DB.
+  class RollbackStatsRepository
+    TABLE_NAME = "actual_db_schema_rollback_events"
+
+    class << self
+      def record(payload)
+        ensure_table!
+        connection.execute(<<~SQL.squish)
+          INSERT INTO #{quoted_table}
+            (#{quoted_column("version")}, #{quoted_column("name")}, #{quoted_column("database")},
+             #{quoted_column("schema")}, #{quoted_column("branch")}, #{quoted_column("manual_mode")},
+             #{quoted_column("created_at")})
+          VALUES
+            (#{connection.quote(payload[:version].to_s)}, #{connection.quote(payload[:name].to_s)},
+             #{connection.quote(payload[:database].to_s)}, #{connection.quote((payload[:schema] || "default").to_s)},
+             #{connection.quote(payload[:branch].to_s)}, #{connection.quote(!!payload[:manual_mode])},
+             #{connection.quote(Time.current)})
+        SQL
+      end
+
+      def stats
+        return empty_stats unless table_exists?
+
+        {
+          total: total_rollbacks,
+          by_database: aggregate_by(:database),
+          by_schema: aggregate_by(:schema),
+          by_branch: aggregate_by(:branch)
+        }
+      end
+
+      def total_rollbacks
+        return 0 unless table_exists?
+
+        connection.select_value(<<~SQL.squish).to_i
+          SELECT COUNT(*) FROM #{quoted_table}
+        SQL
+      end
+
+      def reset!
+        return unless table_exists?
+
+        connection.execute("DELETE FROM #{quoted_table}")
+      end
+
+      private
+
+      def ensure_table!
+        return if table_exists?
+
+        connection.create_table(TABLE_NAME) do |t|
+          t.string :version, null: false
+          t.string :name
+          t.string :database, null: false
+          t.string :schema
+          t.string :branch, null: false
+          t.boolean :manual_mode, null: false, default: false
+          t.datetime :created_at, null: false
+        end
+      end
+
+      def table_exists?
+        connection.table_exists?(TABLE_NAME)
+      end
+
+      def aggregate_by(column)
+        return {} unless table_exists?
+
+        rows = connection.select_all(<<~SQL.squish)
+          SELECT #{quoted_column(column)}, COUNT(*) AS cnt
+          FROM #{quoted_table}
+          GROUP BY #{quoted_column(column)}
+        SQL
+        rows.each_with_object(Hash.new(0)) { |row, h| h[row[column.to_s].to_s] = row["cnt"].to_i }
+      end
+
+      def empty_stats
+        {
+          total: 0,
+          by_database: {},
+          by_schema: {},
+          by_branch: {}
+        }
+      end
+
+      def connection
+        ActiveRecord::Base.connection
+      end
+
+      def quoted_table
+        connection.quote_table_name(TABLE_NAME)
+      end
+
+      def quoted_column(name)
+        connection.quote_column_name(name)
+      end
+    end
+  end
+end

data/lib/actual_db_schema/schema_diff.rb

@@ -19,6 +19,14 @@ module ActualDbSchema
       /create_table\s+["']([^"']+)["']/ => :table
     }.freeze
 
+    SQL_CHANGE_PATTERNS = {
+      /CREATE (?:UNIQUE\s+)?INDEX\s+["']?([^"'\s]+)["']?\s+ON\s+([\w.]+)/i => :index,
+      /CREATE TABLE\s+(\S+)\s+\(/i => :table,
+      /CREATE SEQUENCE\s+(\S+)/i => :table,
+      /ALTER SEQUENCE\s+(\S+)\s+OWNED BY\s+([\w.]+)/i => :table,
+      /ALTER TABLE\s+ONLY\s+(\S+)\s+/i => :table
+    }.freeze
+
     def initialize(schema_path, migrations_path)
       @schema_path = schema_path
       @migrations_path = migrations_path
@@ -48,11 +56,19 @@ module ActualDbSchema
     end
 
     def parsed_old_schema
-      @parsed_old_schema ||= SchemaParser.parse_string(old_schema_content.to_s)
+      @parsed_old_schema ||= parser_class.parse_string(old_schema_content.to_s)
     end
 
     def parsed_new_schema
-      @parsed_new_schema ||= SchemaParser.parse_string(new_schema_content.to_s)
+      @parsed_new_schema ||= parser_class.parse_string(new_schema_content.to_s)
+    end
+
+    def parser_class
+      structure_sql? ? StructureSqlParser : SchemaParser
+    end
+
+    def structure_sql?
+      File.extname(@schema_path) == ".sql"
     end
 
     def migration_changes
@@ -105,8 +121,9 @@ module ActualDbSchema
       lines.each do |line|
         if (hunk_match = line.match(/^@@\s+-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@/))
           current_table = find_table_in_new_schema(hunk_match[3].to_i)
-        elsif (ct = line.match(/create_table\s+["']([^"']+)["']/))
-          current_table = ct[1]
+        elsif (ct = line.match(/create_table\s+["']([^"']+)["']/) ||
+          line.match(/CREATE TABLE\s+"?([^"\s]+)"?/i) || line.match(/ALTER TABLE\s+ONLY\s+(\S+)/i))
+          current_table = normalize_table_name(ct[1])
         end
 
         result_lines << (%w[+ -].include?(line[0]) ? handle_diff_line(line, current_table) : line)
@@ -128,19 +145,24 @@ module ActualDbSchema
     end
 
     def detect_action_and_name(line_content, sign, current_table)
+      patterns = structure_sql? ? SQL_CHANGE_PATTERNS : CHANGE_PATTERNS
       action_map = {
         column: ->(md) { [guess_action(sign, current_table, md[2]), md[2]] },
         index: ->(md) { [sign == "+" ? :add_index : :remove_index, md[1]] },
         table: ->(_) { [sign == "+" ? :create_table : :drop_table, nil] }
       }
 
-      CHANGE_PATTERNS.each do |regex, kind|
+      patterns.each do |regex, kind|
         next unless (md = line_content.match(regex))
 
         action_proc = action_map[kind]
         return action_proc.call(md) if action_proc
       end
 
+      if structure_sql? && current_table && (md = line_content.match(/^\s*"?(\w+)"?\s+(.+?)(?:,|\s*$)/i))
+        return [guess_action(sign, current_table, md[1]), md[1]]
+      end
+
       [nil, nil]
     end
 
@@ -159,8 +181,8 @@ module ActualDbSchema
       current_table = nil
 
       new_schema_content.lines[0...new_line_number].each do |line|
-        if (match = line.match(/create_table\s+["']([^"']+)["']/))
-          current_table = match[1]
+        if (match = line.match(/create_table\s+["']([^"']+)["']/) || line.match(/CREATE TABLE\s+"?([^"\s]+)"?/i))
+          current_table = normalize_table_name(match[1])
         end
       end
       current_table
@@ -171,7 +193,7 @@ module ActualDbSchema
 
       migration_changes.each do |file_path, changes|
         changes.each do |chg|
-          next unless chg[:table].to_s == table_name.to_s
+          next unless (structure_sql? && index_action?(action)) || chg[:table].to_s == table_name.to_s
 
           matches << file_path if migration_matches?(chg, action, col_or_index_name)
         end
@@ -180,6 +202,10 @@ module ActualDbSchema
       matches
     end
 
+    def index_action?(action)
+      %i[add_index remove_index rename_index].include?(action)
+    end
+
     def migration_matches?(chg, action, col_or_index_name)
       return (chg[:action] == action) if col_or_index_name.nil?
 
@@ -225,5 +251,11 @@ module ActualDbSchema
     def annotate_line(line, migration_file_paths)
       "#{line.chomp}#{colorize(" // #{migration_file_paths.join(", ")} //", :gray)}\n"
     end
+
+    def normalize_table_name(table_name)
+      return table_name unless structure_sql? && table_name.include?(".")
+
+      table_name.split(".").last
+    end
   end
 end

data/lib/actual_db_schema/schema_diff_html.rb

@@ -17,7 +17,7 @@ module ActualDbSchema
 
     def generate_diff_html
       diff_output = generate_full_diff(old_schema_content, new_schema_content)
-      return "<pre>#{ERB::Util.html_escape(new_schema_content)}</pre>" if diff_output.strip.empty?
+      diff_output = new_schema_content if diff_output.strip.empty?
 
       process_diff_output_for_html(diff_output)
     end
@@ -43,7 +43,7 @@ module ActualDbSchema
       block_depth = 1
 
       diff_str.lines.each do |line|
-        next if line.start_with?("---") || line.start_with?("+++") || line.match(/^@@/)
+        next if skip_line?(line)
 
         current_table, table_start, block_depth =
           process_table(line, current_table, table_start, result_lines.size, block_depth)
@@ -53,15 +53,21 @@ module ActualDbSchema
       result_lines.join
     end
 
+    def skip_line?(line)
+      line != "---\n" && !line.match(/^--- Name/) &&
+        (line.start_with?("---") || line.start_with?("+++") || line.match(/^@@/))
+    end
+
     def process_table(line, current_table, table_start, table_end, block_depth)
-      if (ct = line.match(/create_table\s+["']([^"']+)["']/))
-        return [ct[1], table_end, block_depth]
+      if (ct = line.match(/create_table\s+["']([^"']+)["']/) || line.match(/CREATE TABLE\s+"?([^"\s]+)"?/i))
+        return [normalize_table_name(ct[1]), table_end, block_depth]
       end
 
       return [current_table, table_start, block_depth] unless current_table
 
       block_depth += line.scan(/\bdo\b/).size unless line.match(/create_table\s+["']([^"']+)["']/)
       block_depth -= line.scan(/\bend\b/).size
+      block_depth -= line.scan(/\);\s*$/).size
 
       if block_depth.zero?
         @tables[current_table] = { start: table_start, end: table_end }
@@ -101,7 +107,7 @@ module ActualDbSchema
     end
 
     def link_to_migration(migration_file_path)
-      migration = migrations.detect { |m| m.filename == migration_file_path }
+      migration = migrations.detect { |m| File.expand_path(m.filename) == File.expand_path(migration_file_path) }
       return ERB::Util.html_escape(migration_file_path) unless migration
 
       url = "migrations/#{migration.version}?database=#{migration.database}"

data/lib/actual_db_schema/structure_sql_parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  # Parses the content of a `structure.sql` file into a structured hash representation.
+  module StructureSqlParser
+    module_function
+
+    def parse_string(sql_content)
+      schema = {}
+      table_regex = /CREATE TABLE\s+(?:"?([\w.]+)"?)\s*\((.*?)\);/m
+      sql_content.scan(table_regex) do |table_name, columns_section|
+        schema[normalize_table_name(table_name)] = parse_columns(columns_section)
+      end
+      schema
+    end
+
+    def parse_columns(columns_section)
+      columns = {}
+      columns_section.each_line do |line|
+        line.strip!
+        next if line.empty? || line =~ /^(CONSTRAINT|PRIMARY KEY|FOREIGN KEY)/i
+
+        match = line.match(/\A"?(?<col>\w+)"?\s+(?<type>\w+)(?<size>\s*\([\d,]+\))?/i)
+        next unless match
+
+        col_name = match[:col]
+        col_type = match[:type].strip.downcase.to_sym
+        options = {}
+        columns[col_name] = { type: col_type, options: options }
+      end
+
+      columns
+    end
+
+    def normalize_table_name(table_name)
+      return table_name unless table_name.include?(".")
+
+      table_name.split(".").last
+    end
+  end
+end

data/lib/actual_db_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActualDbSchema
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

data/lib/actual_db_schema.rb

@@ -4,7 +4,9 @@ require "actual_db_schema/engine"
 require "active_record/migration"
 require "csv"
 require_relative "actual_db_schema/git"
+require_relative "actual_db_schema/rollback_stats_repository"
 require_relative "actual_db_schema/configuration"
+require_relative "actual_db_schema/instrumentation"
 require_relative "actual_db_schema/store"
 require_relative "actual_db_schema/version"
 require_relative "actual_db_schema/migration"
@@ -21,6 +23,7 @@ require_relative "actual_db_schema/railtie"
 require_relative "actual_db_schema/schema_diff"
 require_relative "actual_db_schema/schema_diff_html"
 require_relative "actual_db_schema/schema_parser"
+require_relative "actual_db_schema/structure_sql_parser"
 
 require_relative "actual_db_schema/commands/base"
 require_relative "actual_db_schema/commands/rollback"

data/lib/generators/actual_db_schema/templates/actual_db_schema.rb

@@ -35,4 +35,13 @@ if defined?(ActualDbSchema)
     # config.migrations_storage = :db
     config.migrations_storage = :file
   end
+
+  # Subscribe to rollback events to persist stats (optional).
+  # Uncomment the following to track rollback statistics in the database:
+  #
+  # ActiveSupport::Notifications.subscribe(
+  #   ActualDbSchema::Instrumentation::ROLLBACK_EVENT
+  # ) do |_name, _start, _finish, _id, payload|
+  #   ActualDbSchema::RollbackStatsRepository.record(payload)
+  # end
 end

data/lib/tasks/actual_db_schema.rake

@@ -56,7 +56,8 @@ namespace :actual_db_schema do # rubocop:disable Metrics/BlockLength
 
   desc "Show the schema.rb diff annotated with the migrations that made the changes"
   task :diff_schema_with_migrations, %i[schema_path migrations_path] => :environment do |_, args|
-    schema_path = args[:schema_path] || "./db/schema.rb"
+    default_schema = Rails.configuration.active_record.schema_format == :sql ? "./db/structure.sql" : "./db/schema.rb"
+    schema_path = args[:schema_path] || default_schema
     migrations_path = args[:migrations_path] || "db/migrate"
 
     schema_diff = ActualDbSchema::SchemaDiff.new(schema_path, migrations_path)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actual_db_schema
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Andrei Kaleshka
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-27 00:00:00.000000000 Z
+date: 2026-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -201,6 +201,7 @@ files:
 - lib/actual_db_schema/failed_migration.rb
 - lib/actual_db_schema/git.rb
 - lib/actual_db_schema/git_hooks.rb
+- lib/actual_db_schema/instrumentation.rb
 - lib/actual_db_schema/migration.rb
 - lib/actual_db_schema/migration_context.rb
 - lib/actual_db_schema/migration_parser.rb
@@ -210,10 +211,12 @@ files:
 - lib/actual_db_schema/patches/migration_proxy.rb
 - lib/actual_db_schema/patches/migrator.rb
 - lib/actual_db_schema/railtie.rb
+- lib/actual_db_schema/rollback_stats_repository.rb
 - lib/actual_db_schema/schema_diff.rb
 - lib/actual_db_schema/schema_diff_html.rb
 - lib/actual_db_schema/schema_parser.rb
 - lib/actual_db_schema/store.rb
+- lib/actual_db_schema/structure_sql_parser.rb
 - lib/actual_db_schema/version.rb
 - lib/generators/actual_db_schema/templates/actual_db_schema.rb
 - lib/tasks/actual_db_schema.rake