rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -19,21 +19,23 @@ module RailsAiContext
           return attach_secondary_databases(static_schema_parse)
         end
 
+        tables = extract_tables
         attach_secondary_databases({
           adapter: adapter_name,
-          tables: extract_tables,
-          total_tables: table_names.size,
+          tables: tables,
+          total_tables: SchemaConventions.table_count(tables),
           schema_version: current_schema_version,
           # The version stamp is read off db/schema.rb and the tables off the
           # connection, so the two can be one migration apart. The tables the
           # dump declares are what lets a consumer say so rather than call a
           # declared table a typo.
-          declared_tables: declared_table_names,
-          check_constraints: check_constraints,
+          **declaration_keys,
+          check_constraints: SchemaConventions.check_constraints_of(tables),
           enum_types: enum_types,
-          generated_columns: generated_columns(schema_reader),
+          generated_columns: SchemaConventions.generated_columns_of(tables),
+          extensions: extensions,
           # What names the migration behind a declared table the connection lacks.
-          pending_migrations: RailsAiContext::PendingMigrations.live(RailsAiContext::PendingMigrations.migrate_dir_for(app.root))
+          pending_migrations: RailsAiContext::PendingMigrations.live(RailsAiContext::PendingMigrations.migrate_dirs_for(app.root))
         }.compact)
       end
 
@@ -75,24 +77,150 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, "unknown", label: "adapter_name")
       end
 
+      def sqlite?
+        adapter_name.to_s.match?(/sqlite/i)
+      end
+
+      def postgres?
+        adapter_name.to_s.match?(/postg/i)
+      end
+
+      # Every MySQL adapter inherits mariadb? from AbstractMysqlAdapter.
+      def mysql?
+        connection.respond_to?(:mariadb?)
+      end
+
       def connection
         ActiveRecord::Base.connection
       end
 
       def table_names
-        @table_names ||= (connection.tables - @partitions.to_a)
+        @table_names ||= (connection.tables - @partitions.to_a - sqlite_hidden_tables)
           .reject { |t| t.start_with?("ar_internal_metadata", "schema_migrations") }
       end
 
       def extract_tables
-        table_names.each_with_object({}) do |table, hash|
+        tables = table_names.each_with_object({}) do |table, hash|
           hash[table] = {
             columns: extract_columns(table),
             indexes: extract_indexes(table),
             foreign_keys: extract_foreign_keys(table),
-            primary_key: SchemaConventions.primary_key_value(connection.primary_key(table))
-          }
+            primary_key: SchemaConventions.primary_key_value(connection.primary_key(table)),
+            comment: table_comment(table),
+            unique_constraints: unique_constraints(table),
+            check_constraints: table_check_constraints(table)
+          }.compact
+          SchemaConventions.mark_primary_key(hash[table])
+        end
+        add_live_relations(tables)
+      end
+
+      # connection.tables leaves out views and SQLite's virtual tables; a view's SQL is the dump's.
+      def add_live_relations(tables)
+        materialized, extension_owned = pg_view_names
+        (connection.views - tables.keys - extension_owned).each do |view|
+          # Only a materialized view holds rows, so only it can carry an index.
+          indexes = materialized.include?(view) ? extract_indexes(view) : []
+          tables[view] = SchemaConventions.view_entry(declared_dump.views.dig(view, :sql), materialized: materialized.include?(view),
+                                                      columns: extract_columns(view), indexes: indexes)
+        end
+        sqlite_virtual_tables.each do |name, (mod, arguments)|
+          tables[name] ||= SchemaConventions.virtual_table_entry(mod, arguments.to_s.split(", "))
+        end
+        tables
+      end
+
+      def sqlite_virtual_tables
+        sqlite? ? SqliteVirtualTables.of(connection) : {}
+      end
+
+      def sqlite_hidden_tables
+        sqlite? ? SqliteVirtualTables.hidden(connection) : []
+      end
+
+      PG_VIEWS = <<~SQL
+        SELECT c.relname, c.relkind, EXISTS (SELECT 1 FROM pg_depend d WHERE d.objid = c.oid AND d.deptype = 'e')
+        FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('v', 'm') AND n.nspname = ANY (current_schemas(false))
+      SQL
+
+      # PostgreSQL lists materialized views among the views, and an extension's own
+      # (PostGIS geometry_columns, pg_stat_statements) beside the app's.
+      def pg_view_names
+        return [ [], [] ] unless postgres?
+
+        rows = connection.select_rows(PG_VIEWS)
+        [ rows.select { |_, kind, _| kind == "m" }.map(&:first), rows.select { |*, owned| owned == true || owned == "t" }.map(&:first) ]
+      rescue => e
+        RailsAiContext.debug_fail(e, [ [], [] ], label: "pg_view_names")
+      end
+
+      def table_comment(table)
+        comment = connection.table_comment(table) if connection.supports_comments?
+        comment unless comment.to_s.empty?
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "table_comment")
+      end
+
+      # Rails 7.1+ on PostgreSQL.
+      def unique_constraints(table)
+        return unless connection.respond_to?(:unique_constraints) && connection.supports_unique_constraints?
+
+        found = connection.unique_constraints(table).map do |constraint|
+          SchemaConventions.unique_constraint_entry(constraint.name, constraint.column, constraint.deferrable)
+        end
+        found if found.any?
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "unique_constraints")
+      end
+
+      # The connection's, named as the dump names them: Rails leaves out a chk_rails_ name it made up.
+      def table_check_constraints(table)
+        found = if connection.supports_check_constraints?
+          connection.check_constraints(table).map do |constraint|
+            { name: (constraint.name if constraint.export_name_on_schema_dump?), expression: constraint.expression }.compact
+          end
+        else
+          schema_reader.check_constraints.select { |c| c[:table] == table }.map { |c| c.slice(:name, :expression) }
         end
+        found if found.any?
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "table_check_constraints")
+      end
+
+      def extensions
+        found = connection.extensions if connection.respond_to?(:extensions)
+        Array(found).map(&:to_s) if found.present?
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "extensions")
+      end
+
+      # What schema.rb writes for a column beyond its type: the connection's
+      # limit, precision and collation, less the defaults the dumper leaves out.
+      def column_detail(table, col, bigint)
+        native_limit = (connection.native_database_types[col.type] || {})[:limit]
+        limit = col.limit unless bigint || col.limit == native_limit || col.sql_type.to_s.match?(/\A(?:tiny|medium|long)?(?:text|blob)\b/i)
+        # A datetime's default precision is 6, and MySQL writes none as 0.
+        precision = col.precision unless col.type == :datetime && [ nil, 0, 6 ].include?(col.precision) ||
+                                         col.type == :time && col.precision.to_i.zero? && col.sql_type.to_s.start_with?("time")
+        {
+          limit: limit,
+          precision: precision,
+          scale: col.scale,
+          unsigned: (true if col.respond_to?(:unsigned?) && col.unsigned?),
+          size: (SchemaConventions.mysql_text_size(col.sql_type) if mysql?),
+          collation: (col.collation unless col.collation.nil? || col.collation == table_collation(table))
+        }
+      end
+
+      TABLE_COLLATIONS = "SELECT table_name, table_collation FROM information_schema.tables WHERE table_schema = DATABASE()"
+
+      # MySQL gives every text column the table's collation; the dump names only a different one.
+      def table_collation(table)
+        return unless mysql?
+
+        @table_collations ||= connection.select_rows(TABLE_COLLATIONS).to_h
+        @table_collations[table]
       end
 
       def extract_columns(table)
@@ -104,14 +232,17 @@ module RailsAiContext
           bigint = col.respond_to?(:bigint?) && col.bigint?
           entry = {
             name: col.name,
-            type: bigint ? "bigint" : col.type.to_s,
+            type: bigint ? "bigint" : dumped_type(col),
             null: col.null,
             default: col.default,
-            limit: (col.limit unless bigint),
-            precision: col.precision,
-            scale: col.scale,
+            **column_detail(table, col, bigint),
             comment: col.comment
           }
+          if col.respond_to?(:virtual?) && col.virtual?
+            entry[:generated] = (col.default_function || declared_generated(table, col.name)).to_s
+            entry[:stored] = stored_generated?(col)
+          end
+          entry[:enum_type] = col.sql_type.to_s if col.type == :enum
           # PostgreSQL gives an array's default as its literal ({}), which the
           # static tier reads the way Rails dumps it ([]).
           if col.respond_to?(:array?) && col.array?
@@ -126,29 +257,32 @@ module RailsAiContext
         end
       end
 
+      # MySQL's dumper writes an enum or set column by its full SQL type, and a timestamp as one.
+      def dumped_type(col)
+        return col.type.to_s unless mysql?
+        return col.sql_type.to_s if col.sql_type.to_s.match?(/\A(?:enum|set)\b/)
+
+        col.sql_type.to_s.match?(/\Atimestamp\b/) ? "timestamp" : col.type.to_s
+      end
+
       def extract_indexes(table)
         connection.indexes(table).map do |idx|
-          {
-            name: idx.name,
-            # An expression index's columns come as one String; split into keys as the dump readers do.
-            columns: idx.columns.is_a?(String) ? StructureSqlReader.index_keys(idx.columns) : idx.columns,
-            unique: idx.unique,
-            where: idx.where
-          }.compact
+          # An expression index's columns come as one String; split into keys as the dump readers do.
+          columns = idx.columns.is_a?(String) ? StructureSqlReader.index_keys(idx.columns) : idx.columns
+          detail = SchemaConventions.index_detail(
+            columns, using: idx.using, type: idx.type, order: idx.orders, opclass: idx.opclasses, length: idx.lengths,
+            include: (idx.include if idx.respond_to?(:include)),
+            nulls_not_distinct: (idx.nulls_not_distinct if idx.respond_to?(:nulls_not_distinct))
+          )
+          { name: idx.name, columns: columns, unique: idx.unique, where: idx.where }.compact.merge(detail)
         end
       end
 
       def extract_foreign_keys(table)
         # PostgreSQL clones a key that references a partitioned table once per partition.
         connection.foreign_keys(table).reject { |fk| @partitions.to_a.include?(fk.to_table) }.map do |fk|
-          {
-            from_table: fk.from_table,
-            to_table: fk.to_table,
-            column: fk.column,
-            primary_key: fk.primary_key,
-            on_delete: fk.on_delete,
-            on_update: fk.on_update
-          }.compact
+          SchemaConventions.foreign_key_entry(fk.from_table, fk.to_table, fk.column, fk.primary_key, on_delete: fk.on_delete, on_update: fk.on_update,
+                                                                                                    deferrable: fk.deferrable, validate: fk.validate?)
         end
       rescue => e
         # Some adapters don't support foreign_keys.
@@ -166,14 +300,35 @@ module RailsAiContext
         @schema_reader ||= SchemaReader.new(schema_file_path, partitions: @partitions.to_a)
       end
 
-      # Constraints and enum types are declared in the dump, not reported by
-      # the adapter, so the live tier reads them from schema.rb too.
-      def check_constraints
-        schema_reader.check_constraints
+      # The configured dump, whatever its format: a view's SQL and a MySQL generated expression are not on the connection.
+      def declared_dump
+        format, = present_dump
+        format == :sql ? SchemaReader.for(app.root) : schema_reader
+      end
+
+      # MySQL keeps a generated column's expression out of the column, so the dump says it.
+      def declared_generated(table, name)
+        column = declared_dump.tables.dig(table, :columns)&.find { |c| c[:name] == name }
+        column && (column.dig(:options, :as) || column[:generated])
+      end
+
+      # PostgreSQL before Rails 7.1 had only stored generated columns.
+      def stored_generated?(col)
+        return col.virtual_stored? if col.respond_to?(:virtual_stored?)
+        return col.extra.to_s.match?(/\b(?:STORED|PERSISTENT)\b/) if col.respond_to?(:extra)
+
+        true
       end
 
+      # PostgreSQL's, from the connection: 7.0 gives the labels as one string, 7.1+ as an array.
       def enum_types
-        schema_reader.enums
+        return schema_reader.enums unless connection.respond_to?(:enum_types)
+
+        connection.enum_types.map do |name, values|
+          { name: name.to_s, values: values.is_a?(String) ? values.delete("{}").split(",") : Array(values).map(&:to_s) }
+        end
+      rescue => e
+        RailsAiContext.debug_fail(e, schema_reader.enums, label: "enum_types")
       end
 
       # The tables db/schema.rb declares, or nil when there is no dump to
@@ -182,9 +337,10 @@ module RailsAiContext
       # full parse on every booted call, and a missing note is better than a
       # slow one.
       def declared_table_names
-        return nil unless File.exist?(schema_file_path)
+        return nil unless schema_file_path && File.exist?(schema_file_path)
 
-        names = schema_reader.tables.keys.map(&:to_s)
+        # Virtual tables and tables the dumper skipped count as tables, as the connection lists them.
+        names = (schema_reader.tables.keys + schema_reader.virtual_tables.keys + schema_reader.not_dumped.keys).map(&:to_s).uniq
         names.any? ? names : nil
       rescue => e
         RailsAiContext.debug_fail(e, nil, label: "declared_table_names")
@@ -207,12 +363,37 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, nil, label: "schema_version_for")
       end
 
+      def dump_candidates
+        @dump_candidates ||= SchemaDumpPath.candidates(app.root)
+      end
+
+      # The dump Rails loads for this app, whether or not it is on disk.
+      def schema_dump_name
+        dump_candidates.first.last
+      end
+
+      # The first dump on disk, as the static tier reads it; the configured name when none is.
+      def present_dump
+        @present_dump ||= SchemaDumpPath.present(app.root) || dump_candidates.first
+      end
+
+      # The schema.rb dump the readers answer from, or nil when it is structure.sql.
       def schema_file_path
-        File.join(app.root, "db", "schema.rb")
+        format, path = present_dump
+        path if format == :ruby
+      end
+
+      # A secondary dump's name says its database; the primary's, whatever schema_dump calls it, does not.
+      def secondary_dump(path)
+        path unless dump_candidates.any? { |_, candidate| candidate == path }
+      end
+
+      def migrate_dir_for_dump(path)
+        RailsAiContext::PendingMigrations.migrate_dirs_for(app.root, secondary_dump(path))
       end
 
-      def structure_file_path
-        File.join(app.root, "db", "structure.sql")
+      def relative_dump_path(path)
+        path.delete_prefix("#{app.root.to_s.chomp('/')}/")
       end
 
       def migrations_dir
@@ -226,57 +407,64 @@ module RailsAiContext
       end
 
       def migration_files
-        @migration_files ||= MigrationReplay.migration_files(migrations_dirs)
+        @migration_files ||= MigrationReplay.migration_files(migrations_dirs, root: app.root)
       end
 
-      # Fallback: parse schema file as text when DB isn't connected.
-      # Tries db/schema.rb first, then db/structure.sql, then migrations.
-      # This enables introspection in CI, Claude Code, etc.
+      # Fallback when no database answers: the dump file, then the migrations.
       # Every key the booted answer carries, answered from the files, and
-      # meaning the same thing: `declared_tables` is what db/schema.rb
-      # declares, nil for an app whose tables come from structure.sql or the
-      # migrations.
+      # meaning the same thing: `declared_tables` is what the schema.rb dump
+      # declares and `declared_in` names that dump, both nil for an app whose
+      # tables come from structure.sql or the migrations.
       def static_schema_parse
         result = static_schema_sources
         return result unless result.is_a?(Hash) && result[:tables].is_a?(Hash)
 
-        result.merge(declared_tables: declared_table_names)
+        result.merge(declaration_keys)
       end
 
-      def static_schema_sources
-        schema_rb_exists = File.exist?(schema_file_path)
+      def declaration_keys
+        declared = declared_table_names
+        { declared_tables: declared, declared_in: (relative_dump_path(schema_file_path) if declared) }
+      end
 
-        if schema_rb_exists
-          result = parse_schema_rb(schema_file_path)
-          return result if result[:total_tables].to_i > 0
+      # The configured dump first (database.yml's schema_dump, schema_format), then the default files.
+      def static_schema_sources
+        if (reason = RailsAiContext::AppKind.without_active_record(app.root) || RailsAiContext::AppKind.sequel_schema(app.root))
+          return { unavailable: "#{reason}; ActiveRecord schema introspection does not apply" }
         end
 
-        if File.exist?(structure_file_path)
-          result = parse_structure_sql(structure_file_path)
-          return result if result[:total_tables].to_i > 0
+        present = dump_candidates.select { |_, path| File.exist?(path) }
+        present.each do |format, path|
+          result = parse_dump(format, path)
+          return result if result[:tables].present? || result[:error]
         end
 
         return parse_migrations if migration_files.any?
 
-        # schema.rb exists but has no tables - happens on fresh Rails apps right
-        # after `db:create` where no migrations have been run yet. Return a
-        # legitimate empty-schema state instead of a misleading "not found" error.
-        if schema_rb_exists
+        # An empty schema.rb is a fresh app right after `db:create`, not a missing source.
+        format, path = present.first
+        if format == :ruby
           return {
             total_tables: 0,
             tables: {},
             note: "Schema file exists but is empty - no migrations have been run yet. " \
-                  "Run `bin/rails db:migrate` after generating migrations to populate schema.rb."
+                  "Run `bin/rails db:migrate` after generating migrations to populate #{relative_dump_path(path)}."
           }
+        elsif format == :sql
+          return { total_tables: 0, tables: {}, note: "#{relative_dump_path(path)} has no CREATE TABLE statement this reader could read." }
         end
 
         if RailsAiContext::AppKind.mongoid?(app.root)
           return { unavailable: "this app uses Mongoid; ActiveRecord schema introspection does not apply" }
         end
 
+        if secondary_database_dumps.any?
+          return { total_tables: 0, tables: {}, note: "The primary database has no tables yet: no #{relative_dump_path(schema_dump_name)} or migrations found." }
+        end
+
         # An absent data source, not a failure: :unavailable keeps a fresh
         # greenfield app out of the "introspection failed" warnings banner.
-        { unavailable: "No db/schema.rb, db/structure.sql, or migrations found" }
+        { unavailable: "No #{relative_dump_path(schema_dump_name)} or migrations found" }
       end
 
       # Rails multi-database setups dump each secondary database to its own
@@ -285,24 +473,47 @@ module RailsAiContext
       # dump keeps the top-level :tables shape; secondaries ride their own
       # key so single-database consumers are unaffected.
       def secondary_database_dumps
-        dumps = {}
-        Dir.glob(File.join(app.root.to_s, "db", "*_schema.rb")).sort.each do |path|
-          name = File.basename(path, ".rb").sub(/_schema\z/, "")
-          parsed = parse_schema_rb(path)
-          next unless parsed[:total_tables].to_i.positive?
-
-          parsed[:note] = "Parsed from db/#{File.basename(path)} (from committed dump, not a live connection)"
-          dumps[name] = parsed
+        @secondary_database_dumps ||= read_secondary_database_dumps
+      end
+
+      def read_secondary_database_dumps
+        primary = dump_candidates.map(&:last)
+        configured = SchemaDumpPath.secondaries(app.root).map { |name, (format, path)| [ name, format, path ] }
+        taken = primary + configured.map(&:last)
+        globbed = SchemaDumpPath::FILE_NAMES.flat_map do |format, file|
+          kind, ext = file.split(".")
+          Dir.glob(File.join(app.root.to_s, "db", "*_#{kind}.#{ext}")).sort
+            .reject { |path| taken.include?(path) }
+            .map { |path| [ File.basename(path, ".#{ext}").delete_suffix("_#{kind}"), format, path ] }
+        end
+        dumps = (configured + globbed).each_with_object({}) do |(name, format, path), found|
+          next if found.key?(name) || primary.include?(path) || !File.exist?(path)
+
+          parsed = parse_dump(format, path)
+          next if parsed[:tables].blank?
+
+          parsed[:note] = "Parsed from #{relative_dump_path(path)} (from committed dump, not a live connection)"
+          found[name] = parsed
         end
-        Dir.glob(File.join(app.root.to_s, "db", "*_structure.sql")).sort.each do |path|
-          name = File.basename(path, ".sql").sub(/_structure\z/, "")
+        replay_secondary_migrations(dumps)
+      end
+
+      # A database whose dump is not written yet answers from its own migrations_paths.
+      def replay_secondary_migrations(dumps)
+        RailsAiContext::DatabaseYml.task_secondaries(app.root).each do |name, entry|
           next if dumps.key?(name)
 
-          parsed = parse_structure_sql(path)
-          next unless parsed[:total_tables].to_i.positive?
+          dirs = MigrationReplay.configured_dirs(app.root.to_s, entry) or next
+          pk_type = SchemaConventions.implicit_pk_type(app.root.to_s, database: name)
+          tables = MigrationReplay.tables(dirs, pk_type: pk_type, root: app.root.to_s)
+          next if tables.empty?
 
-          parsed[:note] = "Parsed from db/#{File.basename(path)} (from committed dump, not a live connection)"
-          dumps[name] = parsed
+          tables.each_value { |table| SchemaConventions.mark_primary_key(table) }
+          _, dump = SchemaDumpPath.secondaries(app.root)[name]
+          dumps[name] = {
+            adapter: "static_parse", tables: tables, total_tables: SchemaConventions.table_count(tables),
+            note: "Reconstructed from the migrations in #{dirs.map { |dir| relative_dump_path(dir) }.join(', ')} (#{connection_state}, no #{dump ? relative_dump_path(dump) : "#{name}_schema.rb"})"
+          }
         end
         dumps
       end
@@ -321,9 +532,18 @@ module RailsAiContext
       def static_column(column)
         options = column[:options]
         entry = { name: column[:name], type: column[:type] }
+        if column[:virtual]
+          entry[:generated] = options[:as].is_a?(String) ? options[:as] : ""
+          entry[:stored] = options[:stored] == true
+        end
+        entry[:enum_type] = options[:enum_type].to_s if options[:enum_type].is_a?(Symbol) || options[:enum_type].is_a?(String)
         entry[:null] = false if options[:null] == false
         entry[:default] = column[:default] unless column[:default].nil?
         entry[:array] = true if options[:array] == true
+        %i[limit precision scale].each { |key| entry[key] = options[key] if options[key].is_a?(Integer) }
+        entry[:unsigned] = true if options[:unsigned] == true
+        entry[:size] = options[:size].to_s if options[:size].is_a?(Symbol)
+        entry[:collation] = options[:collation] if options[:collation].is_a?(String)
         entry[:comment] = options[:comment] if options[:comment].is_a?(String)
         entry[:primary_key] = true if column[:primary_key]
         entry
@@ -333,76 +553,97 @@ module RailsAiContext
         columns = index[:columns]
         return nil if columns.empty?
 
+        options = index[:options]
         entry = {
-          name:    index[:options][:name]&.to_s,
+          name:    options[:name]&.to_s,
           columns: columns,
-          unique:  index[:options][:unique] == true,
-          where:   (index[:options][:where] if index[:options][:where].is_a?(String))
+          unique:  options[:unique] == true,
+          where:   (options[:where] if options[:where].is_a?(String))
         }
         # An expression index (e.g. "lower(email)") names no plain column.
         entry[:expression] = true if columns.size == 1 && !columns.first.match?(/\A\w+\z/)
-        entry.compact
+        detail = options.slice(:using, :type, :include, :order, :opclass, :length, :nulls_not_distinct)
+                        .reject { |_, value| value == RailsAiContext::Confidence::INFERRED }
+        entry.compact.merge(SchemaConventions.index_detail(columns, **detail))
+      end
+
+      def parse_dump(format, path)
+        format == :ruby ? parse_schema_rb(path) : parse_structure_sql(path)
       end
 
       def parse_schema_rb(path)
         content = RailsAiContext::SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
-        return { error: "schema.rb too large (#{File.size(path)} bytes)" } unless content
+        return { error: "#{relative_dump_path(path)} too large (#{File.size(path)} bytes, over max_schema_file_size)" } unless content
 
-        schema = SchemaReader.new(path, pk_type: SchemaConventions.implicit_pk_type(app.root.to_s, path))
+        schema = SchemaReader.new(path, pk_type: SchemaConventions.implicit_pk_type(app.root.to_s, secondary_dump(path)))
 
         tables = {}
         schema.tables.each do |table_name, declared|
           next if table_name.start_with?("ar_internal_metadata", "schema_migrations")
 
+          comment = declared.dig(:options, :comment)
+          unique = Array(declared[:unique_constraints]).map do |constraint|
+            SchemaConventions.unique_constraint_entry(constraint.dig(:options, :name), constraint[:columns], constraint.dig(:options, :deferrable))
+          end
           tables[table_name] = {
             columns: declared[:columns].map { |c| static_column(c) },
             indexes: declared[:indexes].filter_map { |i| static_index(i) },
             foreign_keys: [],
+            comment: (comment if comment.is_a?(String)),
+            unique_constraints: (unique if unique.any?),
             unread_calls: declared[:unread_calls]
           }.compact
           key = declared.dig(:options, :primary_key)
           tables[table_name][:primary_key] = SchemaConventions.primary_key_value(key) if key
+          SchemaConventions.mark_primary_key(tables[table_name])
         end
 
         schema.foreign_keys.each do |fk|
           tables[fk[:from]]&.dig(:foreign_keys)&.push(
-            SchemaConventions.foreign_key_entry(fk[:from], fk[:to], fk[:column], fk[:primary_key])
+            SchemaConventions.foreign_key_entry(fk[:from], fk[:to], fk[:column], fk[:primary_key], **fk.slice(*SchemaConventions::FOREIGN_KEY_OPTIONS))
           )
         end
 
-        check_constraints = schema.check_constraints
-        enum_types = schema.enums
+        schema.check_constraints.each do |constraint|
+          table = tables[constraint[:table]] or next
+          (table[:check_constraints] ||= []) << constraint.slice(:name, :expression)
+        end
+        views = schema.views.transform_values { |view| view.merge(indexes: Array(view[:indexes]).filter_map { |i| static_index(i) }) }
+        SchemaConventions.add_relations(tables, views: views, virtual_tables: schema.virtual_tables, not_dumped: schema.not_dumped)
 
         version = schema_version_for(path)
 
         result = {
           adapter: "static_parse",
           tables: tables,
-          total_tables: tables.size,
+          total_tables: SchemaConventions.table_count(tables),
           schema_version: version,
-          check_constraints: check_constraints,
-          enum_types: enum_types,
-          generated_columns: generated_columns(schema),
-          note: "Parsed from db/schema.rb (#{connection_state})"
+          check_constraints: SchemaConventions.check_constraints_of(tables),
+          enum_types: schema.enums,
+          generated_columns: SchemaConventions.generated_columns_of(tables),
+          note: "Parsed from #{relative_dump_path(path)} (#{connection_state})"
         }
+        result[:extensions] = schema.extensions if schema.extensions.any?
         # schema.rb records only the max applied version, so pending here
         # means "migration files newer than the schema version" - exact for
         # linear histories, best-effort for out-of-order merges. With no
         # version recorded there is no answer, so the key stays absent.
         if version
-          migrate_dir = RailsAiContext::PendingMigrations.migrate_dir_for(app.root, path)
-          result[:pending_migrations] = RailsAiContext::PendingMigrations.for(migrate_dir: migrate_dir, applied: version)
+          migrate_dir = migrate_dir_for_dump(path)
+          result[:pending_migrations] = RailsAiContext::PendingMigrations.for(migrate_dir: migrate_dir, applied: version, root: app.root)
         end
         result
       end
 
       def parse_structure_sql(path)
         content = RailsAiContext::SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
-        return { error: "structure.sql too large (#{File.size(path)} bytes)" } unless content
+        return { error: "#{relative_dump_path(path)} too large (#{File.size(path)} bytes, over max_schema_file_size)" } unless content
 
         parsed = StructureSqlReader.parse(content)
         dialect = parsed[:dialect]
         tables = parsed[:tables]
+        tables.each_value { |table| SchemaConventions.mark_primary_key(table) }
+        SchemaConventions.add_relations(tables, views: parsed[:views], virtual_tables: parsed[:virtual_tables])
 
         applied = RailsAiContext::SchemaVersion.applied_versions(content)
 
@@ -410,13 +651,17 @@ module RailsAiContext
           adapter: "static_parse",
           dialect: dialect.to_s,
           tables: tables,
-          total_tables: tables.size,
-          note: "Parsed from db/structure.sql (#{connection_state})"
+          total_tables: SchemaConventions.table_count(tables),
+          check_constraints: SchemaConventions.check_constraints_of(tables),
+          enum_types: parsed[:enums],
+          generated_columns: SchemaConventions.generated_columns_of(tables),
+          note: "Parsed from #{relative_dump_path(path)} (#{connection_state})"
         }
+        result[:extensions] = parsed[:extensions] if parsed[:extensions].any?
         if applied.any?
           result[:schema_version] = applied.map(&:to_i).max.to_s
-          migrate_dir = RailsAiContext::PendingMigrations.migrate_dir_for(app.root, path)
-          result[:pending_migrations] = RailsAiContext::PendingMigrations.for(migrate_dir: migrate_dir, applied: applied)
+          migrate_dir = migrate_dir_for_dump(path)
+          result[:pending_migrations] = RailsAiContext::PendingMigrations.for(migrate_dir: migrate_dir, applied: applied, root: app.root)
         end
         result
       end
@@ -425,25 +670,13 @@ module RailsAiContext
         @connection_state || "no DB connection"
       end
 
-      def generated_columns(schema)
-        schema.tables.flat_map { |table, declared|
-          declared[:columns].filter_map { |column|
-            options = column[:options]
-            next unless options[:virtual] == true || options[:stored] == true
-
-            { table: table, column: column[:name], stored: options[:stored] == true }
-          }
-        }
-      rescue => e
-        RailsAiContext.debug_fail(e, [], label: "generated_columns")
-      end
-
       # A table whose create_table names it through the class has no literal to read, so the
       # count says how many names came from the file instead.
       def replay_note(tables, counts)
         inferred = tables.count { |_, data| data[:inferred_name] }
+        _, dump = SchemaDumpPath.present(app.root.to_s)
         note = "Reconstructed from #{CountPhrase.call(migration_files.size, "migration file")} " \
-               "(#{connection_state}, no schema.rb)"
+               "(#{connection_state}, #{dump ? "#{relative_dump_path(dump)} declares no tables" : "no schema.rb"})"
         note += ", #{CountPhrase.call(inferred, "table name")} read from the file rather than the create_table call" if inferred.positive?
         note += ", #{CountPhrase.call(counts.unnamed, "create_table call")} left unnamed" if counts.unnamed.positive?
         note += ", #{CountPhrase.call(counts.unnamed_columns, "added column")} left unnamed" if counts.unnamed_columns.positive?
@@ -457,14 +690,15 @@ module RailsAiContext
       # rename_table, drop_table, change_column, add_index, add_reference,
       # add_foreign_key, add_timestamps.
       def parse_migrations
-        pk_type = SchemaConventions.implicit_pk_type(app.root.to_s, schema_file_path)
+        pk_type = SchemaConventions.implicit_pk_type(app.root.to_s)
         replayed = MigrationReplay.replayed(migrations_dirs, pk_type: pk_type, root: app.root.to_s)
         tables = replayed.tables
+        tables.each_value { |table| SchemaConventions.mark_primary_key(table) }
 
         {
           adapter: "static_parse",
           tables: tables,
-          total_tables: tables.size,
+          total_tables: SchemaConventions.table_count(tables),
           note: replay_note(tables, replayed.counts)
         }
       end