hecks 3.4.2 → 3.6.0

data/lib/hecks/hecks/adapters/journal_store/edge_audit.rb

@@ -69,14 +69,23 @@ module Hecks
         # The shape not yet minted: the edge that leaves the latest era for the current shape.
         def pending(latest)
           label = Runtime::StorageShape.mint_hash(@held.bluebook)[0, Runtime::StorageShape::LABEL_LENGTH]
-          domain = @held.bluebook.name
-          leaving = @held.registry.translations.select { |t| t.domain == domain && t.from == latest[:label] }
-          edge = leaving.find { |t| t.to == label } or
+          leaving = leaving_edges(latest)
+          edge = edge_to(leaving, latest, label)
+          chain = @manager.edge_chain(@held.registry, @held.bluebook, @eras[0..-2] + [latest], label)
+          finding(chain, latest[:ordinal] + 1, leaving.size, edge)
+        end
+
+        # The leaving edge that arrives at the current shape.
+        def edge_to(leaving, latest, label)
+          leaving.find { |t| t.to == label } or
             raise Runtime::NotFound, "no translation edge leads #{latest[:label]} to #{label} — " \
                                      "run `hecks scaffold_translation` first"
-          ancestors = @eras[0..-2] + [latest]
-          chain = @manager.edge_chain(@held.registry, @held.bluebook, ancestors, label)
-          finding(chain, latest[:ordinal] + 1, leaving.size, edge)
+        end
+
+        # The registered translations that leave the latest era.
+        def leaving_edges(latest)
+          domain = @held.bluebook.name
+          @held.registry.translations.select { |t| t.domain == domain && t.from == latest[:label] }
         end
 
         def finding(chain, era, leaving, edge = chain.last[:translation])
@@ -109,14 +118,22 @@ module Hecks
         end
 
         def describe(aggregate, edge, verdict, records)
-          lines = ["── #{@held.bluebook.name}::#{aggregate.name} (edge #{edge.from} → #{edge.to}, " \
-                   "#{records} record#{'s' unless records == 1})"]
-          verdict.violations.each { |violation| lines << "   REFUSED: #{violation}" }
-          lines << "   dropped (declared data loss): #{verdict.dropped.join(', ')}" unless verdict.dropped.empty?
+          [heading_line(aggregate, edge, records), *verdict_lines(verdict),
+           *verdict.samples.flat_map { |sample| sample_lines(sample) }]
+        end
+
+        def heading_line(aggregate, edge, records)
+          "── #{@held.bluebook.name}::#{aggregate.name} (edge #{edge.from} → #{edge.to}, " \
+            "#{records} record#{"s" unless records == 1})"
+        end
+
+        # What the audit found wrong with, or dropped from, the translated records.
+        def verdict_lines(verdict)
+          lines = verdict.violations.map { |violation| "   REFUSED: #{violation}" }
+          lines << "   dropped (declared data loss): #{verdict.dropped.join(", ")}" unless verdict.dropped.empty?
           unless verdict.unfed.empty?
-            lines << "   unfed (no rule, no default — add default: if required): #{verdict.unfed.join(', ')}"
+            lines << "   unfed (no rule, no default — add default: if required): #{verdict.unfed.join(", ")}"
           end
-          verdict.samples.each { |sample| lines.concat(sample_lines(sample)) }
           lines
         end
 

data/lib/hecks/hecks/adapters/journal_store/readings/attestation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+module Hecks
+  module Adapters
+    class JournalStore
+      module Readings
+        # The text a person reads before attesting to an era whose held text differs from its
+        # digest.
+        module Attestation
+          private
+
+          def attest(held, lineage, ordinal)
+            era = raw_era(held, lineage, ordinal)
+            computed = Digest::SHA256.hexdigest(era[:held_text])
+            return "#{era_name(held, ordinal)}: the held text matches its digest — nothing to re-attest." if
+              era[:held_digest] == computed
+
+            mismatch(held, era, ordinal, computed)
+          end
+
+          def era_name(held, ordinal) = "#{held.bluebook.name} era #{ordinal}"
+
+          def mismatch(held, era, ordinal, computed)
+            [
+              "#{era_name(held, ordinal)}: the held text does NOT match its recorded digest.",
+              "  recorded: #{era[:held_digest] || "(none)"}", "  computed: #{computed}",
+              shape_line(held, era, ordinal),
+              "The held text AS IT NOW STANDS — the original is gone; this is what you would be attesting to:",
+              "─" * 72, era[:held_text], "─" * 72,
+              "Read it, then `hecks reattest #{held.bluebook.name} era=#{ordinal} --confirm` accepts it."
+            ].join("\n")
+          end
+
+          def shape_line(held, era, ordinal)
+            verdict = Translation::Reattest.shape_guard!(
+              domain: held.bluebook.name, ordinal: ordinal, text: era[:held_text], stored_hash: era[:hash],
+              stored_projection: era[:held_projection] && JSON.parse(era[:held_projection])
+            )
+            if verdict == :cosmetic
+              "  shape:    unchanged — the edit is cosmetic (the text still projects to era #{ordinal}'s minted name)"
+            else
+              "  shape:    era #{ordinal} was never named, so no shape comparison is possible — read carefully"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/journal_store/readings/scaffolding.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    class JournalStore
+      module Readings
+        # The edge file that would lead the latest held era to the current shape.
+        module Scaffolding
+          private
+
+          def scaffold(held, lineage, path)
+            eras = held.held_eras(lineage)
+            return Readings.no_era(held.bluebook.name, path) if eras.empty?
+
+            scaffold_latest(held, held.named(eras.last))
+          end
+
+          # The edge text for the latest era, or why there is nothing to scaffold.
+          def scaffold_latest(held, latest)
+            shadow = PostgresEra::LineageManager.shadow(latest[:held_text])
+            return "#{held.bluebook.name} matches era #{latest[:ordinal]} — nothing to scaffold." if
+              Runtime::StorageShape.project(shadow) == held.shape
+
+            edge_text(held, latest, Translation::Scaffold.diff(shadow, held.bluebook))
+          end
+
+          def edge_text(held, latest, diffed)
+            label = Runtime::StorageShape.mint_hash(held.bluebook)[0, Runtime::StorageShape::LABEL_LENGTH]
+            edge = Translation::Scaffold::Edge.new(
+              domain: held.bluebook.name, from: latest[:label], to: label, ordinal: latest[:ordinal] + 1,
+              label: label, aggregates: diffed[:aggregates], retired: diffed[:retired]
+            )
+            text = Translation::Scaffold.render(edge)
+            [*scaffold_notes(edge, text, diffed[:unclaimed]), text].join("\n")
+          end
+
+          def scaffold_notes(edge, text, unclaimed)
+            unresolved = text.scan(/^\s*unresolved /).size
+            notes = ["# Save as translations/#{edge.ordinal}-#{edge.label}.bluebook."]
+            notes << "# #{unresolved} unresolved: decide what each became, then boot." if unresolved.positive?
+            unclaimed.each do |name|
+              notes << "# UNCLAIMED: #{name} existed and now doesn't, and its successor is ambiguous — add " \
+                       "`aggregate \"NewName\", was: #{name.inspect}` (with its rules) or `retired #{name.inspect}`."
+            end
+            notes << "# 0 unresolved: this shape change costs one extra boot and no typing." if notes.size == 1
+            notes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/journal_store/readings.rb

@@ -5,6 +5,8 @@ require "digest"
 require_relative "held_domain"
 require_relative "edge_audit"
 require_relative "compaction"
+require_relative "readings/scaffolding"
+require_relative "readings/attestation"
 
 module Hecks
   module Adapters
@@ -16,6 +18,9 @@ module Hecks
       # a domain that holds no era answers that it holds none, and only `hold_first` holds one.
       # What a reading refuses is a `Runtime::NotFound`, the refusal a launcher words as an answer.
       module Readings
+        include Scaffolding
+        include Attestation
+
         # Words the answer for a domain that holds no era.
         #
         # @param name [String] the domain's name
@@ -99,41 +104,6 @@ module Hecks
           raise Runtime::NotFound, held.incapable_reason unless held.capable?
         end
 
-        def scaffold(held, lineage, path)
-          eras = held.held_eras(lineage)
-          return Readings.no_era(held.bluebook.name, path) if eras.empty?
-
-          latest = held.named(eras.last)
-          shadow = PostgresEra::LineageManager.shadow(latest[:held_text])
-          if Runtime::StorageShape.project(shadow) == held.shape
-            return "#{held.bluebook.name} matches era #{latest[:ordinal]} — nothing to scaffold."
-          end
-
-          edge_text(held, latest, Translation::Scaffold.diff(shadow, held.bluebook))
-        end
-
-        def edge_text(held, latest, diffed)
-          label = Runtime::StorageShape.mint_hash(held.bluebook)[0, Runtime::StorageShape::LABEL_LENGTH]
-          edge = Translation::Scaffold::Edge.new(
-            domain: held.bluebook.name, from: latest[:label], to: label, ordinal: latest[:ordinal] + 1,
-            label: label, aggregates: diffed[:aggregates], retired: diffed[:retired]
-          )
-          text = Translation::Scaffold.render(edge)
-          [*scaffold_notes(edge, text, diffed[:unclaimed]), text].join("\n")
-        end
-
-        def scaffold_notes(edge, text, unclaimed)
-          unresolved = text.scan(/^\s*unresolved /).size
-          notes = ["# Save as translations/#{edge.ordinal}-#{edge.label}.bluebook."]
-          notes << "# #{unresolved} unresolved: decide what each became, then boot." if unresolved.positive?
-          unclaimed.each do |name|
-            notes << "# UNCLAIMED: #{name} existed and now doesn't, and its successor is ambiguous — add " \
-                     "`aggregate \"NewName\", was: #{name.inspect}` (with its rules) or `retired #{name.inspect}`."
-          end
-          notes << "# 0 unresolved: this shape change costs one extra boot and no typing." if notes.size == 1
-          notes
-        end
-
         def audit(held, lineage, path)
           eras = held.held_eras(lineage)
           return Readings.no_era(held.bluebook.name, path) if eras.empty?
@@ -154,33 +124,6 @@ module Hecks
             "AUDIT PASSED — review the samples above; intent is yours to approve."
           end
         end
-
-        def attest(held, lineage, ordinal)
-          era = raw_era(held, lineage, ordinal)
-          computed = Digest::SHA256.hexdigest(era[:held_text])
-          name = "#{held.bluebook.name} era #{ordinal}"
-          return "#{name}: the held text matches its digest — nothing to re-attest." if era[:held_digest] == computed
-
-          [
-            "#{name}: the held text does NOT match its recorded digest.",
-            "  recorded: #{era[:held_digest] || '(none)'}", "  computed: #{computed}", shape_line(held, era, ordinal),
-            "The held text AS IT NOW STANDS — the original is gone; this is what you would be attesting to:",
-            "─" * 72, era[:held_text], "─" * 72,
-            "Read it, then `hecks reattest #{held.bluebook.name} era=#{ordinal} --confirm` accepts it."
-          ].join("\n")
-        end
-
-        def shape_line(held, era, ordinal)
-          verdict = Translation::Reattest.shape_guard!(
-            domain: held.bluebook.name, ordinal: ordinal, text: era[:held_text], stored_hash: era[:hash],
-            stored_projection: era[:held_projection] && JSON.parse(era[:held_projection])
-          )
-          if verdict == :cosmetic
-            "  shape:    unchanged — the edit is cosmetic (the text still projects to era #{ordinal}'s minted name)"
-          else
-            "  shape:    era #{ordinal} was never named, so no shape comparison is possible — read carefully"
-          end
-        end
       end
     end
   end

data/lib/hecks/hecks/adapters/local_files.rb

@@ -49,17 +49,12 @@ module Hecks
       # @return [Hash{Symbol => Hash}] `output:` the report that was printed
       # @raise [ConsoleCapture::Failure] when the name or adapter is refused, or a file exists
       def scaffold(**held)
-        name   = plain(held[:name])
-        files  = stub_files(name, plain(held[:adapter]))
-        target = File.expand_path(plain(held[:dir]) || CLI::DomainStub.directory(name), Dir.pwd)
+        files  = stub_files(plain(held[:name]), plain(held[:adapter]))
+        target = stub_target(held)
         refuse_existing!(target, files.keys)
-        warn "warning: #{target} is inside the hecks clone; keep a service you deploy outside it." if inside_clone?(target)
+        warn_inside_clone(target)
 
-        files.each do |path, text|
-          full = File.join(target, path)
-          FileUtils.mkdir_p(File.dirname(full))
-          File.write(full, text)
-        end
+        write_files(target, files)
         report = scaffold_report(target, files.keys, plain(held[:adapter]))
         puts report
         { output: { value: report } }
@@ -67,6 +62,28 @@ module Hecks
 
       private
 
+      # The directory the stub is written into: the named one, or the snake-cased name under the
+      # current directory.
+      def stub_target(held)
+        File.expand_path(plain(held[:dir]) || CLI::DomainStub.directory(plain(held[:name])), Dir.pwd)
+      end
+
+      # Warns that a service written inside the hecks clone is not one to deploy from there.
+      def warn_inside_clone(target)
+        return unless inside_clone?(target)
+
+        warn "warning: #{target} is inside the hecks clone; keep a service you deploy outside it."
+      end
+
+      # Writes each stub file under `target`, creating the directories on the way.
+      def write_files(target, files)
+        files.each do |path, text|
+          full = File.join(target, path)
+          FileUtils.mkdir_p(File.dirname(full))
+          File.write(full, text)
+        end
+      end
+
       def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
 
       def stub_files(name, adapter)
@@ -81,7 +98,7 @@ module Hecks
         return if taken.empty?
 
         raise ConsoleCapture::Failure,
-              "nothing written; already there: #{taken.map { |full| shown(full) }.join(', ')}"
+              "nothing written; already there: #{taken.map { |full| shown(full) }.join(", ")}"
       end
 
       def inside_clone?(target)

data/lib/hecks/hecks/adapters/pg_admin/ownership.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    class PgAdmin
+      # Makes the ledger role the owner of a database, its schema and everything in it, and says
+      # what was done and what already held.
+      module Ownership
+        # The relations in `public` the role does not own yet.
+        RELATIONS_SQL = <<~SQL
+          SELECT c.relname, c.relkind, pg_get_userbyid(c.relowner) AS owner
+          FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE n.nspname = 'public' AND c.relkind IN ('r', 'p', 'S', 'v', 'm') AND pg_get_userbyid(c.relowner) <> $1
+          ORDER BY c.relkind, c.relname
+        SQL
+
+        # The functions in `public` the role does not own yet.
+        FUNCTIONS_SQL = <<~SQL
+          SELECT p.proname, pg_get_function_identity_arguments(p.oid) AS args
+          FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
+          WHERE n.nspname = 'public' AND pg_get_userbyid(p.proowner) <> $1
+          ORDER BY p.proname
+        SQL
+
+        private
+
+        def ensure_role(admin, role, done, skipped)
+          found = admin.exec_params("SELECT rolsuper, rolbypassrls FROM pg_roles WHERE rolname = $1", [role])
+          return create_role(admin, role, done) if found.ntuples.zero?
+
+          refuse_privileged_role!(role, found[0]) if found[0]["rolsuper"] == "t" || found[0]["rolbypassrls"] == "t"
+          skipped << "role #{role} exists, ordinary"
+        end
+
+        def create_role(admin, role, done)
+          # CREATE ROLE has no IF NOT EXISTS, and concurrent creates can lose on the catalog
+          # index (unique_violation) as well as on duplicate_object, so the block rescues both.
+          admin.exec(<<~SQL)
+            DO $$ BEGIN
+              CREATE ROLE #{admin.quote_ident(role)} LOGIN NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE;
+            EXCEPTION WHEN duplicate_object OR unique_violation THEN NULL;
+            END $$
+          SQL
+          done << "created role #{role} (LOGIN, no SUPERUSER, no BYPASSRLS)"
+        end
+
+        def refuse_privileged_role!(role, found)
+          kind = found["rolsuper"] == "t" ? "a superuser" : "a BYPASSRLS role"
+          raise ConsoleCapture::Failure,
+                "role #{role} already exists as #{kind}: the era write-fence cannot bind it. " \
+                "Pick another role, or ALTER ROLE #{role} NOSUPERUSER NOBYPASSRLS first."
+        end
+
+        def hand_over_database(admin, database, role, done, skipped)
+          owner = admin.exec_params(
+            "SELECT pg_get_userbyid(datdba) AS owner FROM pg_database WHERE datname = $1", [database]
+          )
+          refuse_missing_database!(database) if owner.ntuples.zero?
+          if owner[0]["owner"] == role
+            skipped << "database #{database} already owned by #{role}"
+          else
+            admin.exec("ALTER DATABASE #{admin.quote_ident(database)} OWNER TO #{admin.quote_ident(role)}")
+            done << "database #{database}: owner #{owner[0]["owner"]} -> #{role}"
+          end
+        end
+
+        def refuse_missing_database!(database)
+          raise ConsoleCapture::Failure,
+                "no database #{database}: createdb it first (PostgresEra provisions every table it " \
+                "needs on first connect, never the database itself)"
+        end
+
+        def hand_over_contents(db, role, done)
+          hand_over_schema(db, role, done)
+          hand_over_relations(db, role, done)
+          hand_over_functions(db, role, done)
+        end
+
+        def hand_over_schema(db, role, done)
+          schema = db.exec("SELECT pg_get_userbyid(nspowner) AS owner FROM pg_namespace WHERE nspname = 'public'")
+          return unless schema.ntuples.positive? && schema[0]["owner"] != role
+
+          db.exec("ALTER SCHEMA public OWNER TO #{db.quote_ident(role)}")
+          done << "schema public: owner #{schema[0]["owner"]} -> #{role}"
+        end
+
+        def hand_over_relations(db, role, done)
+          quoted = db.quote_ident(role)
+          relations = db.exec_params(RELATIONS_SQL, [role])
+          relations.each do |row|
+            db.exec("ALTER #{KINDS.fetch(row["relkind"])} #{db.quote_ident(row["relname"])} OWNER TO #{quoted}")
+          end
+          done << "#{relations.ntuples} relation(s) in public -> #{role}" if relations.ntuples.positive?
+        end
+
+        def hand_over_functions(db, role, done)
+          quoted = db.quote_ident(role)
+          functions = db.exec_params(FUNCTIONS_SQL, [role])
+          functions.each do |row|
+            db.exec("ALTER FUNCTION #{db.quote_ident(row["proname"])}(#{row["args"]}) OWNER TO #{quoted}")
+          end
+          done << "#{functions.ntuples} function(s) in public -> #{role}" if functions.ntuples.positive?
+        end
+
+        def ledger_report(database, role, done, skipped)
+          lines = ["#{database} is #{role}'s"]
+          done.each { |line| lines << "  did:     #{line}" }
+          skipped.each { |line| lines << "  already: #{line}" }
+          lines << "  bind it: database \"postgres://#{role}@localhost/#{database}\"" if done.any?
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/pg_admin.rb

@@ -2,6 +2,7 @@
 
 require "uri"
 require_relative "console_capture"
+require_relative "pg_admin/ownership"
 
 module Hecks
   module Adapters
@@ -13,6 +14,8 @@ module Hecks
     # creates the ledger database itself: PostgresEra provisions the tables it needs on first
     # connect, and an operator makes the database with `createdb`.
     class PgAdmin
+      include Ownership
+
       # The role the QA ledger connects as when none is named.
       DEFAULT_ROLE = "hecks_qa"
 
@@ -99,20 +102,21 @@ module Hecks
       def drop_database(**held)
         database = named(held)
         refuse_to_drop!(database)
-        with(dbname: "postgres") do |admin|
-          if exists?(admin, database)
-            admin.exec_params("SELECT pg_terminate_backend(pid) FROM pg_stat_activity " \
-                              "WHERE datname = $1 AND pid <> pg_backend_pid()", [database])
-            admin.exec("DROP DATABASE #{admin.quote_ident(database)}")
-            { report: { value: "dropped database #{database}" } }
-          else
-            { report: { value: "no database #{database}" } }
-          end
-        end
+        with(dbname: "postgres") { |admin| drop_if_exists(admin, database) }
       end
 
       private
 
+      # Ends the sessions on the database and drops it, or reports that it is not there.
+      def drop_if_exists(admin, database)
+        return { report: { value: "no database #{database}" } } unless exists?(admin, database)
+
+        admin.exec_params("SELECT pg_terminate_backend(pid) FROM pg_stat_activity " \
+                          "WHERE datname = $1 AND pid <> pg_backend_pid()", [database])
+        admin.exec("DROP DATABASE #{admin.quote_ident(database)}")
+        { report: { value: "dropped database #{database}" } }
+      end
+
       def refuse_to_drop!(database)
         if SYSTEM_DATABASES.include?(database.downcase) || configured_databases.include?(database)
           raise ConsoleCapture::Failure, "refusing to drop #{database}: it is the ledger, production or " \
@@ -140,83 +144,6 @@ module Hecks
         database
       end
 
-      def ensure_role(admin, role, done, skipped)
-        found = admin.exec_params("SELECT rolsuper, rolbypassrls FROM pg_roles WHERE rolname = $1", [role])
-        if found.ntuples.zero?
-          # CREATE ROLE has no IF NOT EXISTS, and concurrent creates can lose on the catalog
-          # index (unique_violation) as well as on duplicate_object, so the block rescues both.
-          admin.exec(<<~SQL)
-            DO $$ BEGIN
-              CREATE ROLE #{admin.quote_ident(role)} LOGIN NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE;
-            EXCEPTION WHEN duplicate_object OR unique_violation THEN NULL;
-            END $$
-          SQL
-          done << "created role #{role} (LOGIN, no SUPERUSER, no BYPASSRLS)"
-        elsif found[0]["rolsuper"] == "t" || found[0]["rolbypassrls"] == "t"
-          kind = found[0]["rolsuper"] == "t" ? "a superuser" : "a BYPASSRLS role"
-          raise ConsoleCapture::Failure,
-                "role #{role} already exists as #{kind}: the era write-fence cannot bind it. " \
-                "Pick another role, or ALTER ROLE #{role} NOSUPERUSER NOBYPASSRLS first."
-        else
-          skipped << "role #{role} exists, ordinary"
-        end
-      end
-
-      def hand_over_database(admin, database, role, done, skipped)
-        owner = admin.exec_params(
-          "SELECT pg_get_userbyid(datdba) AS owner FROM pg_database WHERE datname = $1", [database]
-        )
-        if owner.ntuples.zero?
-          raise ConsoleCapture::Failure,
-                "no database #{database}: createdb it first (PostgresEra provisions every table it " \
-                "needs on first connect, never the database itself)"
-        elsif owner[0]["owner"] == role
-          skipped << "database #{database} already owned by #{role}"
-        else
-          admin.exec("ALTER DATABASE #{admin.quote_ident(database)} OWNER TO #{admin.quote_ident(role)}")
-          done << "database #{database}: owner #{owner[0]['owner']} -> #{role}"
-        end
-      end
-
-      def hand_over_contents(db, role, done)
-        quoted = db.quote_ident(role)
-        schema = db.exec("SELECT pg_get_userbyid(nspowner) AS owner FROM pg_namespace WHERE nspname = 'public'")
-        if schema.ntuples.positive? && schema[0]["owner"] != role
-          db.exec("ALTER SCHEMA public OWNER TO #{quoted}")
-          done << "schema public: owner #{schema[0]['owner']} -> #{role}"
-        end
-
-        relations = db.exec_params(<<~SQL, [role])
-          SELECT c.relname, c.relkind, pg_get_userbyid(c.relowner) AS owner
-          FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE n.nspname = 'public' AND c.relkind IN ('r', 'p', 'S', 'v', 'm') AND pg_get_userbyid(c.relowner) <> $1
-          ORDER BY c.relkind, c.relname
-        SQL
-        relations.each do |row|
-          db.exec("ALTER #{KINDS.fetch(row['relkind'])} #{db.quote_ident(row['relname'])} OWNER TO #{quoted}")
-        end
-        done << "#{relations.ntuples} relation(s) in public -> #{role}" if relations.ntuples.positive?
-
-        functions = db.exec_params(<<~SQL, [role])
-          SELECT p.proname, pg_get_function_identity_arguments(p.oid) AS args
-          FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
-          WHERE n.nspname = 'public' AND pg_get_userbyid(p.proowner) <> $1
-          ORDER BY p.proname
-        SQL
-        functions.each do |row|
-          db.exec("ALTER FUNCTION #{db.quote_ident(row['proname'])}(#{row['args']}) OWNER TO #{quoted}")
-        end
-        done << "#{functions.ntuples} function(s) in public -> #{role}" if functions.ntuples.positive?
-      end
-
-      def ledger_report(database, role, done, skipped)
-        lines = ["#{database} is #{role}'s"]
-        done.each { |line| lines << "  did:     #{line}" }
-        skipped.each { |line| lines << "  already: #{line}" }
-        lines << "  bind it: database \"postgres://#{role}@localhost/#{database}\"" if done.any?
-        lines.join("\n")
-      end
-
       def exists?(admin, database)
         admin.exec_params("SELECT 1 FROM pg_database WHERE datname = $1", [database]).ntuples.positive?
       end