hecks 3.5.0 → 3.6.0

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/chain_sql.rb

@@ -0,0 +1,169 @@
+require_relative "../../../../../../naming"
+require_relative "../../translation/rule_compiler"
+require_relative "sql_templates"
+
+module Hecks
+  module Adapters
+    class PostgresEra
+      class Lineage
+        # The SQL that derives an era's head from the journal: each ancestor era's rows, cut at
+        # the watermark recorded when its successor was minted, then every edge's rules chained
+        # over them in mint order.
+        module ChainSql
+          include SqlTemplates
+
+          # Reduces the tail before chaining edges over it, not after: every
+          # reader already reduces to latest-per-id, so translating a
+          # superseded entry would be wasted work. `era` survives the
+          # reduction because each edge's case still needs it.
+          def latest_per_id(tail)
+            return tail if tail.to_s.empty?
+
+            "SELECT DISTINCT ON (aggregate_id) ordinal, era, aggregate, aggregate_id, operation, state " \
+              "FROM (#{tail}) tail_entries ORDER BY aggregate_id, ordinal DESC"
+          end
+
+          # Builds era N by layering its own last edge onto era N-1's existing
+          # matview, instead of re-deriving from raw history; returns nil
+          # (falling back to chain_sql) whenever that shortcut can't honestly
+          # apply. `edges.size != era - 1` guards names_by_era's own
+          # assumption that `edges` is the full chain reaching `era` — a
+          # shorter chain here would index names[:storage] out of bounds
+          # rather than safely falling back.
+          def layered_chain_sql(aggregate, era, edges)
+            return nil unless layerable?(era, edges)
+
+            held = eras
+            prior_view = existing_prior_view(aggregate, era, held)
+            return nil unless prior_view
+
+            layered_sql(aggregate, era, edges, held, prior_view)
+          end
+
+          # Chains the original edges in mint order rather than flattening them
+          # into one rule set: edge 1 renaming A→B then edge 2 renaming C→A
+          # has no single phase order that applies both correctly.
+          def chain_sql(aggregate, era, edges)
+            names = names_by_era(aggregate, edges)
+            tail = latest_per_id(ancestor_tail_sql(names, era))
+            chain = edges.each_with_index.map { |edge, index| edge_step_sql(edge, index, names) }
+            format(CHAIN_SQL, tail: tail, chain: chain.join(",\n"), last: edges.size)
+          end
+
+          # Reads through head_body_sql — the same layered-or-full choice
+          # compile_head! makes at mint time — so a preview can't silently
+          # drift from what a real mint will materialize.
+          def translated_latest(aggregate, era, edges)
+            latest_of(head_body_sql(aggregate, era, edges))
+          end
+
+          # The untranslated ancestor tail, latest entry per id — the "before"
+          # side of a per-rule preservation check.
+          def ancestor_latest(aggregate, era, edges)
+            names = names_by_era(aggregate, edges)
+            tail = ancestor_tail_sql(names, era)
+            return {} if tail.empty?
+
+            latest_of("SELECT ordinal, era, aggregate_id, operation, state FROM (#{tail}) tail_rows")
+          end
+
+          # Reduces to newest entry per aggregate id, dropping any id whose
+          # newest entry is a delete rather than returning it with a nil state.
+          def latest_of(sql)
+            rows = @db.exec(format(LATEST_SQL, sql: sql))
+            rows.to_h { |row| [row["aggregate_id"], JSON.parse(row["state"])] }
+          end
+
+          # The one place that picks layered vs full, so a preview
+          # (translated_latest) can never approve a branch the real mint
+          # doesn't take. `full:` mirrors compile_head!'s own default;
+          # tail_merge is the one caller that forces it true.
+          def head_body_sql(aggregate, era, edges, full: false)
+            return chain_sql(aggregate, era, edges) if full
+
+            layered_chain_sql(aggregate, era, edges) || chain_sql(aggregate, era, edges)
+          end
+
+          # Walks `was:` chains backward from the current name, so each
+          # ancestor era's rows can be found under the name of their time.
+          # names[:storage][e - 1] is the storage name for era e (1-based).
+          def names_by_era(aggregate, edges)
+            current = Array.new(edges.size + 1)
+            current[edges.size] = aggregate.name
+            (edges.size - 1).downto(0) { |index| current[index] = name_before(edges, current, index) }
+            { current: current, storage: current.map { |name| Naming.snake(name) } }
+          end
+
+          # Cuts each ancestor era's rows at the watermark recorded when its
+          # successor was minted, so later writes to the old world don't leak in.
+          def ancestor_tail_sql(names, era)
+            watermarks = eras.to_h { |held| [held[:ordinal], held[:watermark]] }
+            selects = (1...era).map do |ancestor|
+              cut = watermarks[ancestor + 1]
+              "SELECT ordinal, era, aggregate, aggregate_id, operation, state FROM #{quoted_journal} " \
+                "WHERE era = #{ancestor} AND aggregate = #{text_literal(names[:storage][ancestor - 1])}" \
+                "#{" AND ordinal <= #{cut}" if cut}"
+            end
+            selects.join(" UNION ALL ")
+          end
+
+          private
+
+          def layerable?(era, edges) = era >= 3 && edges.size >= 2 && edges.size == era - 1
+
+          # The previous era's matview, when it is labelled and already built.
+          def existing_prior_view(aggregate, era, held)
+            prior = held.find { |candidate| candidate[:ordinal] == era - 1 }
+            return nil unless prior && prior[:label]
+
+            view = matview(aggregate.storage_name, era - 1, prior[:label])
+            view if view_exists?(view)
+          end
+
+          def layered_sql(aggregate, era, edges, held, prior_view)
+            names = names_by_era(aggregate, edges)
+            declared = edges.last[:translation].for_aggregate(names[:current][edges.size])
+            tokens = layered_tokens(prior_view, names, era, declared)
+            format(LAYERED_SQL, tokens.merge(cut: cut_clause(held, era)))
+          end
+
+          def layered_tokens(prior_view, names, era, declared)
+            { prior_view: quote(prior_view), journal: quoted_journal, prior_era: era - 1,
+              aggregate: text_literal(names[:storage][era - 2]),
+              id_column: id_column_for(declared, "operation = 'save'"), expression: rules_expression(declared) }
+          end
+
+          # Cuts the previous era's rows at the watermark recorded when this era was minted.
+          def cut_clause(held, era)
+            cut = held.find { |candidate| candidate[:ordinal] == era }&.dig(:watermark)
+            " AND ordinal <= #{cut}" if cut
+          end
+
+          # One link of the chain: its edge's rules over the previous link.
+          def edge_step_sql(edge, index, names)
+            declared = edge[:translation].for_aggregate(names[:current][index + 1])
+            guard = "era <= #{index + 1} AND operation = 'save'"
+            "edge_#{index + 1} AS (SELECT ordinal, era, #{id_column_for(declared, guard)}, operation, " \
+              "CASE WHEN #{guard} THEN #{rules_expression(declared)} ELSE state END AS state " \
+              "FROM #{index.zero? ? "tail" : "edge_#{index}"})"
+          end
+
+          def rules_expression(declared)
+            declared ? Translation::RuleCompiler.compile_rules(declared) : "state"
+          end
+
+          def id_column_for(declared, guard)
+            return "aggregate_id" unless Translation::RuleCompiler.rekeyed?(declared)
+
+            Translation::RuleCompiler.id_case(guard, declared)
+          end
+
+          def name_before(edges, current, index)
+            declared = edges[index][:translation].for_aggregate(current[index + 1])
+            declared&.was || current[index + 1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/domain_rename.rb

@@ -0,0 +1,91 @@
+require_relative "../../../../../../naming"
+require_relative "../../../../../../runtime/errors"
+
+module Hecks
+  module Adapters
+    class PostgresEra
+      class Lineage
+        # The domain rename bridge: moves a domain's journal, sequence, partitions and lineage
+        # rows from its `formerly_known_as` name to the current one.
+        module DomainRename
+          # Moves a domain's journal, sequence, partitions and lineage rows from
+          # `formerly_known_as` to the current name, in one transaction.
+          #
+          # Runs before `provisioner?` and the CREATE TABLE calls in `ensure_base!`; a no-op when
+          # `hecks_eras` is missing, the new name has rows, or the former name has none.
+          # Locks go in a fixed order (old before new, eras before ordinal) so nothing deadlocks.
+          #
+          # @return [void]
+          # @raise [Runtime::WiringError] if the locks are not granted within 10s or Postgres
+          #   refuses a statement (prechecks included); both roll back first
+          def rename_domain!
+            rename_in_transaction! if rename_pending?
+          rescue PG::LockNotAvailable
+            rollback_quietly
+            raise Runtime::WiringError,
+                  "cannot rename #{@formerly_known_as} to #{@domain}: another rename, mint, or write holds " \
+                  "one of the domain locks — waited 10s; try again shortly"
+          rescue PG::Error => e
+            rollback_quietly
+            raise Runtime::WiringError, "cannot rename #{@formerly_known_as} to #{@domain}: #{e.message.strip}"
+          end
+
+          private
+
+          def rename_pending?
+            return false unless @db.exec_params("SELECT to_regclass($1)", ["hecks_eras"])[0]["to_regclass"]
+            return false if domain_rows?(@domain)
+
+            domain_rows?(@formerly_known_as)
+          end
+
+          def domain_rows?(domain)
+            @db.exec_params("SELECT 1 FROM hecks_eras WHERE domain = $1 LIMIT 1", [domain]).ntuples.positive?
+          end
+
+          def rename_in_transaction!
+            old_journal = "hecks_journal_#{Naming.snake(@formerly_known_as)}"
+            ordinals = @db.exec_params(
+              "SELECT ordinal FROM hecks_eras WHERE domain = $1 ORDER BY ordinal", [@formerly_known_as]
+            ).map { |row| row["ordinal"].to_i }
+
+            @db.exec("BEGIN")
+            @db.exec("SET LOCAL lock_timeout = '10s'")
+            rename_lock_keys.each { |key| @db.exec_params("SELECT pg_advisory_xact_lock(hashtext($1))", [key]) }
+            rename_relations!(old_journal, ordinals)
+            rename_rows!
+            @db.exec("COMMIT")
+          end
+
+          def rename_lock_keys
+            [
+              "hecks_eras:#{@formerly_known_as}", "hecks_eras:#{@domain}",
+              "hecks_ordinal:#{@formerly_known_as}", "hecks_ordinal:#{@domain}"
+            ]
+          end
+
+          def rename_relations!(old_journal, ordinals)
+            @db.exec("ALTER TABLE #{quote(old_journal)} RENAME TO #{quote(journal)}")
+            # The sequence is a plain create sequence, not owned by the column, so it
+            # does not move with the table and needs its own rename.
+            @db.exec("ALTER SEQUENCE #{quote("#{old_journal}_ordinal")} RENAME TO #{quote(sequence)}")
+            # Renaming the parent does not rename its partitions.
+            ordinals.each do |ordinal|
+              @db.exec("ALTER TABLE #{quote("#{old_journal}_era_#{ordinal}")} RENAME TO #{quote(partition(ordinal))}")
+            end
+          end
+
+          def rename_rows!
+            %w[hecks_eras hecks_era_texts hecks_approvals].each do |table|
+              @db.exec_params("UPDATE #{table} SET domain = $1 WHERE domain = $2", [@domain, @formerly_known_as])
+            end
+            # hecks_attestations is created lazily on first reattest!, so it may not exist.
+            return unless @db.exec_params("SELECT to_regclass($1)", ["hecks_attestations"])[0]["to_regclass"]
+
+            @db.exec_params("UPDATE hecks_attestations SET domain = $1 WHERE domain = $2", [@domain, @formerly_known_as])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/era_integrity.rb

@@ -0,0 +1,99 @@
+require_relative "../../era_tamper"
+require_relative "../../../../../../runtime/registry"
+
+module Hecks
+  module Adapters
+    class PostgresEra
+      class Lineage
+        # Era text integrity: each held text is verified against its stored digest before use,
+        # and a drifted digest is resolved only by an append-only attestation.
+        module EraIntegrity
+          # The DDL for the append-only attestation record.
+          CREATE_ATTESTATIONS_SQL = <<~SQL.freeze
+            CREATE TABLE IF NOT EXISTS hecks_attestations (
+              domain      text NOT NULL,
+              ordinal     int  NOT NULL,
+              old_digest  text,
+              new_digest  text NOT NULL,
+              attested_at timestamptz NOT NULL DEFAULT now()
+            )
+          SQL
+
+          # Skips the integrity check `eras` runs, so hecks reattest can show the raw row first.
+          def raw_era(ordinal)
+            rows = @db.exec_params(
+              "SELECT held_text, held_digest, hash, held_projection::text FROM hecks_eras WHERE domain = $1 AND ordinal = $2",
+              [@domain, ordinal]
+            )
+            return nil if rows.ntuples.zero?
+
+            { held_text: rows[0]["held_text"], held_digest: rows[0]["held_digest"], hash: rows[0]["hash"],
+              held_projection: rows[0]["held_projection"] }
+          end
+
+          # Resolves drift via an append-only attestation record — never patch the digest.
+          def reattest!(ordinal)
+            era = raw_era(ordinal)
+            raise Runtime::WiringError, "#{@domain} holds no era #{ordinal} to re-attest" unless era
+
+            fresh = Digest::SHA256.hexdigest(era[:held_text])
+            @db.exec(CREATE_ATTESTATIONS_SQL)
+            record_attestation!(ordinal, era[:held_digest], fresh)
+            adopt_digest!(ordinal, fresh)
+            archive_text!(ordinal, era[:held_text])
+            fresh
+          end
+
+          # A row with no stored digest yet is backfilled, not refused; only a mismatch raises.
+          def verify_integrity!(ordinal, text, stored_digest, stored_projection_json)
+            digest = Digest::SHA256.hexdigest(text)
+            store_missing_digest!(ordinal, digest) if stored_digest.nil?
+            unless stored_digest.nil? || stored_digest == digest
+              raise Runtime::WiringError, Runtime::EraTamper.refusal(domain: @domain, ordinal: ordinal)
+            end
+
+            backfill_frozen_facts!(ordinal, text, stored_projection_json)
+          end
+
+          # Call only on already-verified text; this would bless an unverified edit.
+          def backfill_frozen_facts!(ordinal, text, stored_projection_json)
+            archive_text!(ordinal, text)
+            return if stored_projection_json
+
+            projection = Runtime::EraTamper.project(text)
+            return unless projection
+
+            @db.exec_params(
+              "UPDATE hecks_eras SET held_projection = $3::text::jsonb " \
+              "WHERE domain = $1 AND ordinal = $2 AND held_projection IS NULL",
+              [@domain, ordinal, JSON.generate(projection)]
+            )
+          end
+
+          private
+
+          def record_attestation!(ordinal, old_digest, new_digest)
+            @db.exec_params(
+              "INSERT INTO hecks_attestations (domain, ordinal, old_digest, new_digest) VALUES ($1, $2, $3, $4)",
+              [@domain, ordinal, old_digest, new_digest]
+            )
+          end
+
+          def adopt_digest!(ordinal, digest)
+            @db.exec_params(
+              "UPDATE hecks_eras SET held_digest = $3 WHERE domain = $1 AND ordinal = $2",
+              [@domain, ordinal, digest]
+            )
+          end
+
+          def store_missing_digest!(ordinal, digest)
+            @db.exec_params(
+              "UPDATE hecks_eras SET held_digest = $3 WHERE domain = $1 AND ordinal = $2 AND held_digest IS NULL",
+              [@domain, ordinal, digest]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/era_store.rb

@@ -22,79 +22,6 @@ module Hecks
             end
           end
 
-          # Skips the integrity check `eras` runs, so hecks reattest can show the raw row first.
-          def raw_era(ordinal)
-            rows = @db.exec_params(
-              "SELECT held_text, held_digest, hash, held_projection::text FROM hecks_eras WHERE domain = $1 AND ordinal = $2",
-              [@domain, ordinal]
-            )
-            return nil if rows.ntuples.zero?
-
-            { held_text: rows[0]["held_text"], held_digest: rows[0]["held_digest"], hash: rows[0]["hash"],
-              held_projection: rows[0]["held_projection"] }
-          end
-
-          # Resolves drift via an append-only attestation record — never patch the digest.
-          def reattest!(ordinal)
-            era = raw_era(ordinal)
-            raise Runtime::WiringError, "#{@domain} holds no era #{ordinal} to re-attest" unless era
-
-            fresh = Digest::SHA256.hexdigest(era[:held_text])
-            @db.exec(<<~SQL)
-              CREATE TABLE IF NOT EXISTS hecks_attestations (
-                domain      text NOT NULL,
-                ordinal     int  NOT NULL,
-                old_digest  text,
-                new_digest  text NOT NULL,
-                attested_at timestamptz NOT NULL DEFAULT now()
-              )
-            SQL
-            @db.exec_params(
-              "INSERT INTO hecks_attestations (domain, ordinal, old_digest, new_digest) VALUES ($1, $2, $3, $4)",
-              [@domain, ordinal, era[:held_digest], fresh]
-            )
-            @db.exec_params(
-              "UPDATE hecks_eras SET held_digest = $3 WHERE domain = $1 AND ordinal = $2",
-              [@domain, ordinal, fresh]
-            )
-            archive_text!(ordinal, era[:held_text])
-            fresh
-          end
-
-          # A row with no stored digest yet is backfilled, not refused; only a mismatch raises.
-          def verify_integrity!(ordinal, text, stored_digest, stored_projection_json)
-            digest = Digest::SHA256.hexdigest(text)
-            if stored_digest.nil?
-              @db.exec_params(
-                "UPDATE hecks_eras SET held_digest = $3 WHERE domain = $1 AND ordinal = $2 AND held_digest IS NULL",
-                [@domain, ordinal, digest]
-              )
-              backfill_frozen_facts!(ordinal, text, stored_projection_json)
-              return
-            end
-            if stored_digest == digest
-              backfill_frozen_facts!(ordinal, text, stored_projection_json)
-              return
-            end
-
-            raise Runtime::WiringError, Runtime::EraTamper.refusal(domain: @domain, ordinal: ordinal)
-          end
-
-          # Call only on already-verified text; this would bless an unverified edit.
-          def backfill_frozen_facts!(ordinal, text, stored_projection_json)
-            archive_text!(ordinal, text)
-            return if stored_projection_json
-
-            projection = Runtime::EraTamper.project(text)
-            return unless projection
-
-            @db.exec_params(
-              "UPDATE hecks_eras SET held_projection = $3::text::jsonb " \
-              "WHERE domain = $1 AND ordinal = $2 AND held_projection IS NULL",
-              [@domain, ordinal, JSON.generate(projection)]
-            )
-          end
-
           def current_era
             held = eras
             held.empty? ? 1 : held.last[:ordinal]

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/field_cache.rb

@@ -39,21 +39,7 @@ module Hecks
           # @raise [PG::Error] if Postgres refuses the DDL, a source read, or an upsert
           def ensure_field_cache!(storage_name, era, field, value_expression)
             name = field_cache(storage_name, era, field)
-            unless table_exists?(name)
-              nested_transaction("hecks_field_cache_create") do
-                @db.exec_params("SELECT pg_advisory_xact_lock(hashtext('hecks_field_cache:' || $1))", [name])
-                next if table_exists?(name)
-
-                @db.exec(<<~SQL)
-                  CREATE TABLE #{quote(name)} (
-                    id      text PRIMARY KEY,
-                    ordinal bigint NOT NULL,
-                    value   text
-                  )
-                SQL
-                @db.exec("CREATE INDEX IF NOT EXISTS #{quote("#{name}_value_idx")} ON #{quote(name)} (value)")
-              end
-            end
+            create_field_cache_table!(name) unless table_exists?(name)
             backfill_field_cache!(name, storage_name, era, value_expression)
             name
           end
@@ -70,16 +56,8 @@ module Hecks
           def backfill_field_cache!(name, storage_name, era, value_expression)
             chunked_backfill!(
               name,
-              source_sql: lambda do |cursor|
-                <<~SQL
-                  SELECT id, ordinal, value FROM (#{field_cache_source_sql(storage_name, era, value_expression)}) reduced
-                  #{"WHERE id > #{text_literal(cursor)}" if cursor}
-                  ORDER BY id LIMIT #{ResumableBackfill::CHUNK_SIZE}
-                SQL
-              end,
-              upsert:     lambda do |rows|
-                upsert_field_cache_rows!(name, rows)
-              end
+              source_sql: ->(cursor) { cache_backfill_page_sql(cursor, storage_name, era, value_expression) },
+              upsert:     ->(rows) { upsert_field_cache_rows!(name, rows) }
             )
           end
 
@@ -117,30 +95,56 @@ module Hecks
 
           private
 
+          # Creates the cache table under a short advisory lock, unless a racing boot made it first.
+          def create_field_cache_table!(name)
+            nested_transaction("hecks_field_cache_create") do
+              @db.exec_params("SELECT pg_advisory_xact_lock(hashtext('hecks_field_cache:' || $1))", [name])
+              next if table_exists?(name)
+
+              @db.exec(field_cache_ddl(name))
+              @db.exec("CREATE INDEX IF NOT EXISTS #{quote("#{name}_value_idx")} ON #{quote(name)} (value)")
+            end
+          end
+
+          def field_cache_ddl(name)
+            <<~SQL
+              CREATE TABLE #{quote(name)} (
+                id      text PRIMARY KEY,
+                ordinal bigint NOT NULL,
+                value   text
+              )
+            SQL
+          end
+
+          # One chunk of the reduced head, after `cursor` when the backfill resumes.
+          def cache_backfill_page_sql(cursor, storage_name, era, value_expression)
+            <<~SQL
+              SELECT id, ordinal, value FROM (#{field_cache_source_sql(storage_name, era, value_expression)}) reduced
+              #{"WHERE id > #{text_literal(cursor)}" if cursor}
+              ORDER BY id LIMIT #{ResumableBackfill::CHUNK_SIZE}
+            SQL
+          end
+
           # The reduced (id, ordinal, state) source a cache backfills from. Unlike the head
           # snapshot's source it reduces the ancestor tail too (era N > 1 mirrors `compile_head!`)
           # with ordinal kept; ordinals share one sequence per domain, so `ordinal <` holds.
           def field_cache_source_sql(storage_name, era, value_expression)
             era = era.to_i
-            if era == 1
-              return "SELECT id, ordinal, #{value_expression} AS value " \
-                     "FROM #{quote(head_snapshot(storage_name, era))}"
-            end
+            return era_one_cache_source_sql(storage_name, era, value_expression) if era == 1
 
-            held = eras.find { |candidate| candidate[:ordinal] == era }
-            view = held && held[:label] && matview(storage_name, era, held[:label])
-            ancestor_side =
-              if view && view_exists?(view)
-                "SELECT ordinal, aggregate_id AS id, state FROM #{quote(view)} WHERE operation = 'save'"
-              else
-                # No compiled ancestor matview yet (era just minted): snapshot side only.
-                "SELECT NULL::bigint AS ordinal, NULL::text AS id, NULL::jsonb AS state WHERE FALSE"
-              end
+            merged_cache_source_sql(storage_name, era, value_expression)
+          end
+
+          def era_one_cache_source_sql(storage_name, era, value_expression)
+            "SELECT id, ordinal, #{value_expression} AS value " \
+              "FROM #{quote(head_snapshot(storage_name, era))}"
+          end
 
+          def merged_cache_source_sql(storage_name, era, value_expression)
             <<~SQL
               SELECT id, ordinal, #{value_expression} AS value FROM (
                 SELECT DISTINCT ON (id) id, ordinal, state FROM (
-                  #{ancestor_side}
+                  #{ancestor_side_sql(storage_name, era)}
                   UNION ALL
                   SELECT ordinal, id, state FROM #{quote(head_snapshot(storage_name, era))}
                 ) merged ORDER BY id, ordinal DESC
@@ -148,6 +152,18 @@ module Hecks
             SQL
           end
 
+          # The ancestor era's saved rows from its compiled matview, or an empty relation.
+          def ancestor_side_sql(storage_name, era)
+            held = eras.find { |candidate| candidate[:ordinal] == era }
+            view = held && held[:label] && matview(storage_name, era, held[:label])
+            if view && view_exists?(view)
+              return "SELECT ordinal, aggregate_id AS id, state FROM #{quote(view)} WHERE operation = 'save'"
+            end
+
+            # No compiled ancestor matview yet (era just minted): snapshot side only.
+            "SELECT NULL::bigint AS ordinal, NULL::text AS id, NULL::jsonb AS state WHERE FALSE"
+          end
+
           def upsert_field_cache_rows!(name, rows)
             rows.each do |row|
               @db.exec_params(