rails-ai-context 5.32.0 → 5.32.2

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -8,6 +8,10 @@ module RailsAiContext
       extend StaticTier
       static_tier :alternate_source
 
+      # dump path => [what the dump was read under, its DumpLookup], kept across runs for a later lookup.
+      DUMP_LOOKUPS = Concurrent::Map.new
+      private_constant :DUMP_LOOKUPS
+
       # @return [Hash] database schema context
       def call
         return attach_secondary_databases(static_schema_parse) unless active_record_connected?
@@ -23,6 +27,7 @@ module RailsAiContext
         attach_secondary_databases({
           adapter: adapter_name,
           tables: tables,
+          search_path: live_search_path,
           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
@@ -45,6 +50,36 @@ module RailsAiContext
         attach_secondary_databases(static_schema_parse)
       end
 
+      # A table asked for by a schema-qualified name the listing does not hold. Read only when
+      # asked, since an app can hold a schema per tenant.
+      def self.qualified_table(name, database: nil, live: false)
+        RailsAiContext::RunCache.fetch([ :qualified_table, name, database, live ]) do
+          new(RailsAiContext.default_app).qualified_table(name, database: database, live: live)
+        end
+      end
+
+      def self.qualified_table_note(name)
+        new(RailsAiContext.default_app).qualified_table_note(name)
+      end
+
+      # [the name the listing shows it under, the table] from the connection or the dump, whichever tier answers.
+      def qualified_table(name, database: nil, live: false)
+        return unless name.to_s.include?(".")
+
+        if live
+          data = live_qualified_table(name) or return
+          return [ live_listed_name(name) || name, data ]
+        end
+
+        found = dump_lookup(database)&.table(name)
+        found if found&.last
+      end
+
+      # Why the primary's schema.rb leaves out a schema-qualified table, or nil.
+      def qualified_table_note(name)
+        dump_lookup(nil)&.missing&.call(name)
+      end
+
       private
 
       def active_record_connected?
@@ -100,19 +135,50 @@ module RailsAiContext
       end
 
       def extract_tables
-        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)),
-            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)
+        add_live_relations(table_names.to_h { |table| [ table, table_entry(table) ] })
+      end
+
+      def table_entry(table)
+        entry = {
+          columns: extract_columns(table),
+          indexes: extract_indexes(table),
+          foreign_keys: extract_foreign_keys(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(entry)
+        entry
+      end
+
+      # The schemas the connection searches, which name its enum types; public alone is the default.
+      # SQL, as 8.1's connection.current_schemas runs it (schema_statements.rb:242-246), which 7.0 to 8.0 lack.
+      def live_search_path
+        return unless postgres?
+
+        found = connection.select_value("SELECT current_schemas(false)")
+        found = found.to_s.delete_prefix("{").delete_suffix("}").split(",").map { |schema| schema.delete('"') } unless found.is_a?(Array)
+        found unless found == PgNaming::DEFAULT_SEARCH_PATH
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "search_path")
+      end
+
+      # The bare name, when the search path resolves it to this same table, as connection.tables lists it.
+      def live_listed_name(name)
+        bare = name.split(".").last
+        same = connection.select_value("SELECT to_regclass(#{connection.quote(connection.quote_table_name(bare))}) = " \
+                                       "to_regclass(#{connection.quote(connection.quote_table_name(name))})")
+        bare if same
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "listed_name")
+      end
+
+      # quoted_scope reads a qualified name's own schema (schema_statements.rb:1179-1191).
+      def live_qualified_table(name)
+        table_entry(name) if postgres? && connection.data_source_exists?(name)
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "qualified_table")
       end
 
       # connection.tables leaves out views and SQLite's virtual tables; a view's SQL is the dump's.
@@ -190,7 +256,7 @@ module RailsAiContext
 
       def extensions
         found = connection.extensions if connection.respond_to?(:extensions)
-        Array(found).map(&:to_s) if found.present?
+        Array(found).map(&:to_s).sort if found.present?
       rescue => e
         RailsAiContext.debug_fail(e, nil, label: "extensions")
       end
@@ -297,7 +363,9 @@ module RailsAiContext
       end
 
       def schema_reader
-        @schema_reader ||= SchemaReader.new(schema_file_path, partitions: @partitions.to_a)
+        @schema_reader ||= SchemaReader.new(schema_file_path, partitions: @partitions.to_a, search_path: RailsAiContext::DatabaseYml.schema_search_path(app.root),
+                                                              user_schema: RailsAiContext::DatabaseYml.user_schema(app.root),
+                                                              rails_version: rails_version)
       end
 
       # The configured dump, whatever its format: a view's SQL and a MySQL generated expression are not on the connection.
@@ -326,7 +394,7 @@ module RailsAiContext
 
         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
+        end.sort_by { |enum| enum[:name] }
       rescue => e
         RailsAiContext.debug_fail(e, schema_reader.enums, label: "enum_types")
       end
@@ -476,7 +544,8 @@ module RailsAiContext
         @secondary_database_dumps ||= read_secondary_database_dumps
       end
 
-      def read_secondary_database_dumps
+      # [name, format, path] for each secondary database's dump on disk, the configured first.
+      def secondary_dump_files
         primary = dump_candidates.map(&:last)
         configured = SchemaDumpPath.secondaries(app.root).map { |name, (format, path)| [ name, format, path ] }
         taken = primary + configured.map(&:last)
@@ -486,8 +555,12 @@ module RailsAiContext
             .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)
+        (configured + globbed).reject { |_, _, path| primary.include?(path) || !File.exist?(path) }
+      end
+
+      def read_secondary_database_dumps
+        dumps = secondary_dump_files.each_with_object({}) do |(name, format, path), found|
+          next if found.key?(name)
 
           parsed = parse_dump(format, path)
           next if parsed[:tables].blank?
@@ -568,48 +641,73 @@ module RailsAiContext
       end
 
       def parse_dump(format, path)
-        format == :ruby ? parse_schema_rb(path) : parse_structure_sql(path)
+        read_dump(format, path).first
       end
 
-      def parse_schema_rb(path)
-        content = RailsAiContext::SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
-        return { error: "#{relative_dump_path(path)} too large (#{File.size(path)} bytes, over max_schema_file_size)" } unless content
+      # [the schema answer, a DumpLookup over the same parse]
+      def read_dump(format, path)
+        read_at = Time.now
+        stamp = lookup_stamp(path)
+        found = format == :ruby ? read_schema_rb(path) : read_structure_sql(path)
+        # A same-size rewrite inside one mtime tick keeps the whole stat, as AstCache knows.
+        DUMP_LOOKUPS[path] = [ stamp, found.last ] if found.last && stamp.first < read_at - RailsAiContext::AstCache::RACY_WINDOW
+        found
+      end
 
-        schema = SchemaReader.new(path, pk_type: SchemaConventions.implicit_pk_type(app.root.to_s, secondary_dump(path)))
+      # Every input the reader takes besides the file; pk_type is bigint for every PostgreSQL dump.
+      def lookup_stamp(path)
+        stat = File.stat(path)
+        [ stat.mtime, stat.size, stat.ino, search_path_for(path), rails_version,
+          RailsAiContext::DatabaseYml.user_schema(app.root, database_name_for(path)) ]
+      end
 
-        tables = {}
-        schema.tables.each do |table_name, declared|
-          next if table_name.start_with?("ar_internal_metadata", "schema_migrations")
+      # The tables of one dump by the names a lookup may ask for.
+      DumpLookup = Struct.new(:listed, :qualified, :names, :missing, :placed) do
+        def table(name)
+          shown = names.relation(name)
+          return [ name, qualified[shown] ] if shown.include?(".")
 
-          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])
+          [ shown, listed[shown] ] if placed
         end
+      end
+
+      def dump_lookup(database)
+        adapter = SchemaConventions.database_adapter_for(app.root.to_s, database || "primary")
+        return if adapter && !adapter.start_with?("postg")
+
+        _, format, path = database ? secondary_dump_files.find { |name, _, _| name == database } : [ nil, *present_dump ]
+        return unless path && File.exist?(path)
+
+        cached = DUMP_LOOKUPS[path]
+        cached && cached.first == lookup_stamp(path) ? cached.last : read_dump(format, path).last
+      end
+
+      def read_schema_rb(path)
+        content = RailsAiContext::SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
+        return [ { error: "#{relative_dump_path(path)} too large (#{File.size(path)} bytes, over max_schema_file_size)" }, nil ] unless content
+
+        search_path = search_path_for(path)
+        schema = SchemaReader.new(path, pk_type: SchemaConventions.implicit_pk_type(app.root.to_s, secondary_dump(path)), search_path: search_path,
+                                        user_schema: RailsAiContext::DatabaseYml.user_schema(app.root, database_name_for(path)), rails_version: rails_version)
+
+        tables = static_tables(schema.tables)
+        qualified = static_tables(schema.qualified_tables)
+        every = tables.merge(qualified)
 
         schema.foreign_keys.each do |fk|
-          tables[fk[:from]]&.dig(:foreign_keys)&.push(
+          every[fk[:from]]&.dig(:foreign_keys)&.push(
             SchemaConventions.foreign_key_entry(fk[:from], fk[:to], fk[:column], fk[:primary_key], **fk.slice(*SchemaConventions::FOREIGN_KEY_OPTIONS))
           )
         end
 
         schema.check_constraints.each do |constraint|
-          table = tables[constraint[:table]] or next
+          table = every[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)
+        # A view outside the search path is findable only by its qualified name, as a table is.
+        tables.keys.select { |name| name.include?(".") }.each { |name| qualified[name] = tables.delete(name) }
 
         version = schema_version_for(path)
 
@@ -623,7 +721,8 @@ module RailsAiContext
           generated_columns: SchemaConventions.generated_columns_of(tables),
           note: "Parsed from #{relative_dump_path(path)} (#{connection_state})"
         }
-        result[:extensions] = schema.extensions if schema.extensions.any?
+        result[:search_path] = schema.search_path unless schema.search_path == PgNaming::DEFAULT_SEARCH_PATH
+        result[:extensions] = schema.extensions.sort 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
@@ -632,17 +731,42 @@ module RailsAiContext
           migrate_dir = migrate_dir_for_dump(path)
           result[:pending_migrations] = RailsAiContext::PendingMigrations.for(migrate_dir: migrate_dir, applied: version, root: app.root)
         end
-        result
+        missing = ->(name) { PgNaming.missing_from_schema_rb(name, search_path, schema.schemas, schema.dump_version, relative_dump_path(path)) }
+        placed = PgNaming.dump_places_names?(schema.dump_version, schema.search_path)
+        [ result, DumpLookup.new(tables, qualified, schema.names, missing, placed) ]
       end
 
-      def parse_structure_sql(path)
+      def static_tables(declared_tables)
+        declared_tables.each_with_object({}) do |(table_name, declared), tables|
+          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
+      end
+
+      def read_structure_sql(path)
         content = RailsAiContext::SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
-        return { error: "#{relative_dump_path(path)} too large (#{File.size(path)} bytes, over max_schema_file_size)" } unless content
+        return [ { error: "#{relative_dump_path(path)} too large (#{File.size(path)} bytes, over max_schema_file_size)" }, nil ] unless content
 
-        parsed = StructureSqlReader.parse(content)
+        parsed = StructureSqlReader.parse(content, search_path: search_path_for(path), rails_version: rails_version)
         dialect = parsed[:dialect]
         tables = parsed[:tables]
         tables.each_value { |table| SchemaConventions.mark_primary_key(table) }
+        parsed[:qualified_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)
@@ -657,13 +781,26 @@ module RailsAiContext
           generated_columns: SchemaConventions.generated_columns_of(tables),
           note: "Parsed from #{relative_dump_path(path)} (#{connection_state})"
         }
-        result[:extensions] = parsed[:extensions] if parsed[:extensions].any?
+        result[:search_path] = parsed[:names].path unless parsed[:names].path == PgNaming::DEFAULT_SEARCH_PATH
+        result[:extensions] = parsed[:extensions].sort if parsed[:extensions].any?
         if applied.any?
           result[:schema_version] = applied.map(&:to_i).max.to_s
           migrate_dir = migrate_dir_for_dump(path)
           result[:pending_migrations] = RailsAiContext::PendingMigrations.for(migrate_dir: migrate_dir, applied: applied, root: app.root)
         end
-        result
+        [ result, DumpLookup.new(tables, parsed[:qualified_tables], parsed[:names], ->(_) { }, true) ]
+      end
+
+      def rails_version
+        @rails_version ||= PgNaming.rails_version(app.root)
+      end
+
+      def search_path_for(dump_path)
+        RailsAiContext::DatabaseYml.schema_search_path(app.root, database_name_for(dump_path))
+      end
+
+      def database_name_for(dump_path)
+        SchemaDumpPath.database_name(app.root.to_s, secondary_dump(dump_path))
       end
 
       def connection_state

data/lib/rails_ai_context/introspectors/schema_reader.rb

@@ -28,6 +28,9 @@ module RailsAiContext
       end
 
       def self.choose(root)
+        search_path = RailsAiContext::DatabaseYml.schema_search_path(root)
+        user_schema = RailsAiContext::DatabaseYml.user_schema(root)
+        version = PgNaming.rails_version(root)
         return from_tables({}, source: :none, path: nil) if RailsAiContext::AppKind.sequel_schema(root)
 
         candidates = SchemaDumpPath.candidates(root)
@@ -35,12 +38,15 @@ module RailsAiContext
           next unless File.exist?(path)
 
           if format == :ruby
-            reader = new(path, pk_type: SchemaConventions.implicit_pk_type(root))
+            reader = new(path, pk_type: SchemaConventions.implicit_pk_type(root), search_path: search_path, user_schema: user_schema,
+                                    rails_version: version)
             return reader.with_source(:schema_rb) if reader.tables.any?
           else
             content = RailsAiContext::SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
-            parsed = content && StructureSqlReader.parse(content)
-            return from_tables(parsed[:tables], source: :structure_sql, path: path, views: parsed[:views]) if parsed && parsed[:tables].any?
+            parsed = content && StructureSqlReader.parse(content, search_path: search_path, rails_version: version)
+            if parsed && parsed[:tables].any?
+              return from_tables(parsed[:tables], source: :structure_sql, path: path, views: parsed[:views], qualified_tables: parsed[:qualified_tables])
+            end
           end
         end
 
@@ -56,9 +62,9 @@ module RailsAiContext
 
       # A reader over an already-parsed tables hash, for the sources that do
       # not go through the schema.rb event fold.
-      def self.from_tables(tables, source:, path:, views: {})
+      def self.from_tables(tables, source:, path:, views: {}, qualified_tables: {})
         reader = allocate
-        reader.send(:initialize_from_tables, tables, source, path, views)
+        reader.send(:initialize_from_tables, tables, source, path, views, qualified_tables)
         reader
       end
 
@@ -66,8 +72,13 @@ module RailsAiContext
 
       # partitions: the tables the database says are partitions, which a
       # schema.rb from before Rails 8 dumps as plain tables.
-      def initialize(path, pk_type: nil, partitions: [])
+      # search_path: the database's configured schema_search_path; rails_version: the app's, else the
+      # dump's stamp. Together they decide the names the booted app reads. user_schema: the one "$user" names.
+      def initialize(path, pk_type: nil, partitions: [], search_path: PgNaming::DEFAULT_SEARCH_PATH, user_schema: nil, rails_version: nil)
         @path = path
+        @search_path = search_path
+        @user_schema = user_schema
+        @rails_version = rails_version
         @pk_type = pk_type
         @partitions = partitions
         @source = File.exist?(path.to_s) ? :schema_rb : :none
@@ -83,6 +94,40 @@ module RailsAiContext
         parse[:tables]
       end
 
+      # @return [Hash] the tables the search path does not show bare, by schema-qualified name
+      def qualified_tables
+        parse[:qualified_tables]
+      end
+
+      # The configured search path less the schemas the dump never creates.
+      def search_path
+        names.path
+      end
+
+      # How the booted app names this dump's relations and types.
+      def names
+        parse[:names]
+      end
+
+      # @return [Array<String>] the schemas the dump creates
+      def schemas
+        parse[:schemas]
+      end
+
+      # The app's Rails version, else the one the dump is stamped with: the connection's naming.
+      def rails_version
+        parse[:rails_version]
+      end
+
+      # The Rails version that wrote the dump, from its stamp, else the app's: the dump's naming.
+      def dump_version
+        parse[:dump_version]
+      end
+
+      def table?(name)
+        tables.key?(name) || qualified_tables.key?(name)
+      end
+
       # @return [Array<Hash>] { from:, to:, column:, primary_key: } per declared
       #   foreign key, whichever source the schema was read from
       def foreign_keys
@@ -139,7 +184,7 @@ module RailsAiContext
 
       attr_reader :path
 
-      def initialize_from_tables(tables, source, path, views)
+      def initialize_from_tables(tables, source, path, views, qualified_tables)
         @path = path
         @pk_type = nil
         @source = source
@@ -155,13 +200,16 @@ module RailsAiContext
           check_constraints: [],
           extensions: [],
           views: views,
+          qualified_tables: qualified_tables,
           virtual_tables: {},
-          not_dumped: {}
+          not_dumped: {},
+          schemas: [],
+          names: PgNaming.names(PgNaming::DEFAULT_SEARCH_PATH)
         }
       end
 
       def columns_for(table)
-        tables.dig(table, :columns) || []
+        tables.dig(table, :columns) || qualified_tables.dig(table, :columns) || []
       end
 
       def parse
@@ -169,7 +217,8 @@ module RailsAiContext
       end
 
       def empty_schema
-        { tables: {}, foreign_keys: [], enums: [], check_constraints: [], extensions: [], views: {}, virtual_tables: {}, not_dumped: {} }
+        { tables: {}, qualified_tables: {}, foreign_keys: [], enums: [], check_constraints: [], extensions: [], views: {}, virtual_tables: {},
+          not_dumped: {}, schemas: [], names: PgNaming.names(@search_path || PgNaming::DEFAULT_SEARCH_PATH), rails_version: @rails_version }
       end
 
       def build
@@ -179,6 +228,11 @@ module RailsAiContext
         events.sort_by { |e| e[:location] }.each do |event|
           current = absorb(event, schema, current)
         end
+        # The same loop writes that table's foreign keys twice (8.0 schema_dumper.rb:134-156).
+        schema[:foreign_keys].uniq!
+        name_relations(schema)
+        # The connection lists a table only when the search path shows it bare.
+        schema[:tables].keys.select { |name| name.include?(".") }.each { |name| schema[:qualified_tables][name] = schema[:tables].delete(name) }
 
         drop_partitions(schema)
       rescue => e
@@ -215,7 +269,7 @@ module RailsAiContext
         size = File.size(path)
         return [] if size > RailsAiContext.configuration.max_schema_file_size
 
-        listeners = { schema: -> { Listeners::SchemaDslListener.new } }
+        listeners = { schema: -> { Listeners::SchemaDslListener.new(raw_names: true) } }
         results = if size <= RailsAiContext::AstCache::MAX_PARSE_SIZE
           SourceIntrospector.walk(path, listeners)
         else
@@ -226,6 +280,32 @@ module RailsAiContext
         results[:schema] || []
       end
 
+      # The booted app's names: a dump before 8.1 already holds them, a later one qualifies them.
+      def name_relations(schema)
+        # ActiveRecord::Schema[x.y] is Migration.current_version when dumped (schema_dumper.rb:90).
+        stamp = schema.delete(:stamp)
+        schema[:rails_version] ||= stamp
+        version = schema[:dump_version] = stamp || schema[:rails_version]
+        # A 7.0 dump names no schema, so only the "$user" one, which rarely exists, is taken as missing.
+        created = PgNaming.dump_lists_schemas?(version) ? schema[:schemas] : @search_path - [ @user_schema ]
+        path = PgNaming.existing_path(@search_path, created)
+        schema[:names] = PgNaming.names(path)
+        return unless PgNaming.dump_qualifies_names?(version)
+
+        names = schema[:names] = PgNaming.names(path, relations: schema[:tables].keys + schema[:views].keys + schema[:virtual_tables].keys,
+                                                      types: schema[:enums].map { |enum| enum[:name] })
+        %i[tables views virtual_tables not_dumped].each { |key| schema[key] = schema[key].transform_keys { |name| names.relation(name) } }
+        schema[:foreign_keys].each { |fk| fk.merge!(from: names.relation(fk[:from]), to: names.relation(fk[:to])) }
+        schema[:check_constraints].each { |constraint| constraint[:table] = names.relation(constraint[:table]) if constraint[:table] }
+        schema[:enums] = PgNaming.enum_list(schema[:enums].to_h { |enum| [ enum[:name], enum[:values] ] }, path, schema[:rails_version])
+        schema[:tables].each_value do |table|
+          table[:columns].each do |column|
+            type = column.dig(:options, :enum_type)
+            column[:options] = column[:options].merge(enum_type: names.type(type)) if type.is_a?(String)
+          end
+        end
+      end
+
       # Returns the table each subsequent column and index belongs to.
       def absorb(event, schema, current)
         case event[:type]
@@ -234,7 +314,9 @@ module RailsAiContext
           # With a pk_type, the implied id is a column like any other - the
           # convention lives in SchemaConventions, shared with the replay.
           implied = @pk_type ? SchemaConventions.implicit_primary_key(options, @pk_type) : []
-          schema[:tables][event[:table]] ||= { options: options, columns: implied, indexes: [] }
+          # Before 8.1 the dumper writes a name once per search path schema holding it; loading, the last stands.
+          schema[:check_constraints].reject! { |constraint| constraint[:table] == event[:table] } if schema[:tables].key?(event[:table])
+          schema[:tables][event[:table]] = { options: options, columns: implied, indexes: [] }
           return event[:table]
         when :column
           schema[:tables][current]&.dig(:columns)&.push(column_entry(event)) if current
@@ -254,6 +336,10 @@ module RailsAiContext
           schema[:extensions] << event[:name]
         when :enum
           schema[:enums] << { name: event[:name], values: event[:values] }
+        when :create_schema
+          schema[:schemas] << event[:name]
+        when :stamp
+          schema[:stamp] = event[:version] || PgNaming::UNSTAMPED_DUMP
         when :check_constraint
           schema[:check_constraints] << { table: current, **event.slice(:name, :expression) } if current
         when :add_check_constraint