exwiw 0.9.20 → 0.9.22

data/lib/exwiw/cli.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'logger'
 require 'optparse'
 require 'pathname'
@@ -11,7 +12,18 @@ require 'exwiw'
 
 module Exwiw
   class CLI
-    KNOWN_SUBCOMMANDS = %w[export explain].freeze
+    KNOWN_SUBCOMMANDS = %w[export explain schema].freeze
+
+    # The verbs `exwiw schema` takes, mirroring the `exwiw:schema:*` rake tasks
+    # a Rails application would run instead.
+    SCHEMA_VERBS = %w[generate check tidy].freeze
+
+    # `schema check` exit codes. 1 means "the config needs work" — that is the
+    # signal CI acts on — so a failure to *perform* the check (an unreachable
+    # database, a malformed config) must not use it, or an infrastructure
+    # problem reads as a schema problem and gets "fixed" by regenerating.
+    SCHEMA_CHECK_DIRTY_EXIT = 1
+    SCHEMA_CHECK_ERROR_EXIT = 2
 
     # Config file loaded automatically when --config is omitted, if one exists in
     # the current directory. Kept at the project root (rather than under exwiw/)
@@ -52,7 +64,8 @@ module Exwiw
     REJECTED_CONNECTION_KEYS = %w[host port user database uri password].freeze
 
     # Keys that only make sense for `export`. They are skipped when merging config
-    # for `explain` so a shared config file does not trip validate_explain_only!.
+    # for `explain` so a shared config file does not trip validate_explain_only!,
+    # and for `schema`, which performs no export at all.
     EXPORT_ONLY_CONFIG_KEYS = %w[output_dir output_format insert_only after_insert_hook parallel_workers].freeze
 
     def self.start(argv)
@@ -69,6 +82,16 @@ module Exwiw
           "export"
         end
 
+      # `schema` is the one subcommand taking a verb of its own
+      # (`exwiw schema generate`), so the next positional argument belongs to
+      # it. An unknown or missing verb is not consumed here — validation
+      # reports it with the list of valid ones rather than OptionParser
+      # failing on a stray argument.
+      @schema_verb =
+        if @subcommand == "schema" && !@argv.empty? && !@argv.first.start_with?("-")
+          @argv.shift
+        end
+
       @help = @argv.empty?
 
       @database_host = nil
@@ -78,6 +101,7 @@ module Exwiw
       @connection_uri = nil
       @output_dir = nil
       @schema_dir = nil
+      @from_db = false
       @config_file_path = nil
       @database_adapter = nil
       @database_name = nil
@@ -151,9 +175,94 @@ module Exwiw
           io: $stdout,
           explain_verbosity: @explain_verbosity,
         ).run
+      when "schema"
+        run_schema(connection_config)
       end
     end
 
+    # `exwiw schema generate|check|tidy --from-db`: the same three operations
+    # the `exwiw:schema:*` rake tasks perform for a Rails application, driven
+    # from a database connection instead of from the application's models.
+    private def run_schema(connection_config)
+      introspector = DbIntrospector.build(connection_config)
+
+      case @schema_verb
+      when "generate" then run_schema_generate(introspector)
+      when "tidy" then run_schema_tidy(introspector)
+      when "check" then run_schema_check(introspector)
+      end
+    end
+
+    private def run_schema_generate(introspector)
+      DbSchemaGenerator.new(
+        introspector: introspector,
+        output_dir: @schema_dir,
+        safe_new_columns: schema_safe_new_columns?,
+      ).generate!
+
+      puts "exwiw: wrote the schema config for #{@database_name} to #{@schema_dir}."
+    end
+
+    private def run_schema_tidy(introspector)
+      result = DbSchemaGenerator.new(introspector: introspector, output_dir: @schema_dir).tidy!
+
+      if result.empty?
+        puts "exwiw: schema config is already tidy; nothing to remove."
+        return
+      end
+
+      result.removed_tables.each do |name|
+        puts "exwiw: removed config for table '#{name}' (no longer exists in the database)."
+      end
+      result.removed_columns.each do |table_name, columns|
+        puts "exwiw: removed column(s) #{columns.join(', ')} from '#{table_name}' (no longer in the table)."
+      end
+      result.removed_belongs_tos.each do |table_name, targets|
+        puts "exwiw: removed belongs_to(s) to #{targets.join(', ')} from '#{table_name}' " \
+             "(the target table no longer exists)."
+      end
+    end
+
+    private def run_schema_check(introspector)
+      # Regenerate exactly as `generate` + `tidy` would, into the copy
+      # SchemaCheck hands over, so the report is the diff against a config that
+      # has been through both steps rather than only the first.
+      regenerator = lambda do |tmp_dir|
+        # Explicit: safe mode is not optional here, whatever the library default is.
+        DbSchemaGenerator.new(introspector: introspector, output_dir: tmp_dir, safe_new_columns: true).generate!
+        DbSchemaGenerator.new(introspector: introspector, output_dir: tmp_dir).tidy!
+      end
+
+      report =
+        begin
+          SchemaCheck.new(schema_dir: @schema_dir, regenerator: regenerator).run
+        rescue StandardError => e
+          # See SCHEMA_CHECK_ERROR_EXIT: not being able to run the check is a
+          # different answer from "the config is out of date".
+          $stderr.puts "exwiw: could not run the schema check (#{e.class}: #{e.message})"
+          exit SCHEMA_CHECK_ERROR_EXIT
+        end
+
+      json = JSON.pretty_generate(report)
+      puts json
+      # A file too, so a caller need not assume stdout carries only the JSON.
+      File.write(ENV["EXWIW_SCHEMA_CHECK_OUTPUT"], json + "\n") if ENV["EXWIW_SCHEMA_CHECK_OUTPUT"]
+
+      return if SchemaCheck.clean?(report)
+
+      $stderr.puts "exwiw: the schema config is out of date or has undecided masking; " \
+                   "run `exwiw schema generate --from-db` (then `exwiw schema tidy --from-db`) " \
+                   "and resolve every `needs_mask_decision` column."
+      exit SCHEMA_CHECK_DIRTY_EXIT
+    end
+
+    # Safe mode is on unless EXWIW_NEW_COLUMNS=plain, matching the rake task: a
+    # first-time bootstrap wants it off, since there every column is new and
+    # flagging the whole config at once is noise.
+    private def schema_safe_new_columns?
+      ENV["EXWIW_NEW_COLUMNS"] != "plain"
+    end
+
     private def validate_options!
       # Fill in any options not given on the CLI from the config file. Done first
       # so a config-provided `adapter` is in place before normalization below.
@@ -188,6 +297,16 @@ module Exwiw
         resolve_explain_verbosity!
       end
 
+      # `schema` shares only the connection options with the other subcommands:
+      # it neither extracts rows nor reads a dump target, so every check below
+      # is about an export it will not perform. Its own requirements — a schema
+      # source, an introspectable adapter, a schema dir the verb can use — are
+      # validated instead.
+      if @subcommand == "schema"
+        validate_schema_options!
+        return
+      end
+
       if @database_adapter != "sqlite"
         # When a connection URI is supplied (mongodb only), host/port/database
         # are read from the URI, so none of them are required on the CLI.
@@ -315,7 +434,9 @@ module Exwiw
 
       # For `explain`, drop export-only keys so a config shared with `export`
       # does not make validate_explain_only! reject the run.
-      config = config.reject { |k, _| EXPORT_ONLY_CONFIG_KEYS.include?(k) } if @subcommand == "explain"
+      if @subcommand == "explain" || @subcommand == "schema"
+        config = config.reject { |k, _| EXPORT_ONLY_CONFIG_KEYS.include?(k) }
+      end
 
       @database_adapter ||= config["adapter"]
       @schema_dir ||= expand_dir(config["schema_dir"], base)
@@ -494,6 +615,66 @@ module Exwiw
       exit 1
     end
 
+    # Everything `exwiw schema <verb>` needs, and nothing the export path
+    # requires. Runs instead of the export/explain validations, not after them.
+    private def validate_schema_options!
+      unless SCHEMA_VERBS.include?(@schema_verb)
+        $stderr.puts "Usage: exwiw schema #{SCHEMA_VERBS.join('|')} --from-db [options] " \
+                     "(got #{@schema_verb.inspect})"
+        exit 1
+      end
+
+      # The schema source is spelled out rather than assumed. Reading a live
+      # database is one way to describe an application's schema and not the
+      # only conceivable one, so the flag keeps the command unambiguous today
+      # and leaves the reader expecting alternatives tomorrow.
+      unless @from_db
+        $stderr.puts "`exwiw schema #{@schema_verb}` requires --from-db to say where the schema is read from " \
+                     "(a live database connection). A Rails application can use the exwiw:schema:#{@schema_verb} " \
+                     "rake task instead, which reads its models."
+        exit 1
+      end
+
+      unless DbIntrospector::SUPPORTED_ADAPTERS.include?(@database_adapter)
+        $stderr.puts "--from-db supports the #{DbIntrospector::SUPPORTED_ADAPTERS.join(' and ')} adapters only " \
+                     "(got '#{@database_adapter}'). sqlite and mongodb schemas are not read this way."
+        exit 1
+      end
+
+      {
+        "Target database host" => @database_host,
+        "Target database port" => @database_port,
+        "Target database name" => @database_name,
+        "Database user" => @database_user,
+      }.each do |name, value|
+        if value.nil?
+          $stderr.puts "#{name} is required"
+          exit 1
+        end
+      end
+
+      # Deliberately no DATABASE_PASSWORD requirement, unlike export: schema
+      # generation is commonly run in CI against a throwaway database started
+      # with trust/empty authentication, and refusing an empty password would
+      # make the check unrunnable exactly where it is most wanted. The password
+      # is still used when set.
+
+      if @schema_dir.nil?
+        $stderr.puts "Schema dir is required (pass --schema-dir or set schema_dir in the config file)"
+        exit 1
+      end
+
+      # `generate` is also the bootstrap command, so it creates the directory;
+      # `check` and `tidy` only ever read an existing config, and a missing
+      # directory there means the wrong path far more often than an empty one.
+      if @schema_verb == "generate"
+        FileUtils.mkdir_p(@schema_dir)
+      elsif !Dir.exist?(@schema_dir)
+        $stderr.puts "Schema dir does not exist: #{@schema_dir}"
+        exit 1
+      end
+    end
+
     private def validate_explain_only!
       rejected = []
       rejected << "--output-dir" unless @output_dir.nil?
@@ -603,6 +784,11 @@ module Exwiw
                       For mongodb, set verbosity via EXWIW_MONGODB_EXPLAIN_VERBOSITY
                       or `explain_verbosity:` in config (queryPlanner (default,
                       no query is executed) | executionStats | allPlansExecution).
+            schema    Maintain the schema config (generate | check | tidy) by
+                      reading a live database, for applications that cannot be
+                      loaded to generate it from their models. Requires --from-db;
+                      mysql and postgresql only. `check` prints a JSON report and
+                      exits 1 when the config needs work.
         BANNER
         opts.version = Exwiw::VERSION
 
@@ -617,6 +803,7 @@ module Exwiw
           v = v.end_with?("/") ? v[0..-2] : v
           @schema_dir = File.expand_path(v)
         end
+        opts.on("--from-db", "Read the schema from the database the connection options point at (schema subcommand only; mysql/postgresql). Required by `exwiw schema`.") { @from_db = true }
         opts.on("-c", "--config=CONFIG_FILE_PATH", "Path to the exwiw config YAML. Defaults to ./#{DEFAULT_CONFIG_PATHS.first} (or .#{File.extname(DEFAULT_CONFIG_PATHS.last)}) when present. CLI options take precedence; paths inside the file are resolved relative to the file.") do |v|
           @config_file_path = File.expand_path(v)
         end

data/lib/exwiw/db_introspector/mysql_introspector.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Exwiw
+  module DbIntrospector
+    # Reads MySQL's `information_schema`, scoped to `DATABASE()` — the database
+    # the connection was opened against, which is the one the dump would run in.
+    #
+    # Connects through MysqlClient, the same wrapper the dump path uses, so the
+    # driver choice (mysql2 or trilogy) and the "install the gem" error message
+    # are shared rather than reimplemented here.
+    class MysqlIntrospector < Base
+      # MySQL data_type (the type without its length/precision) -> the
+      # ActiveRecord-ish symbol DefaultMask understands. Anything absent maps to
+      # nil, which leaves the column unmasked: binary/blob columns must not
+      # receive a text mask, and enum/set/geometry/bit have no constant that is
+      # valid for every table's declaration.
+      TYPE_MAP = {
+        "char" => :string,
+        "varchar" => :string,
+        "tinytext" => :text,
+        "text" => :text,
+        "mediumtext" => :text,
+        "longtext" => :text,
+        "tinyint" => :integer,
+        "smallint" => :integer,
+        "mediumint" => :integer,
+        "int" => :integer,
+        "integer" => :integer,
+        "bigint" => :integer,
+        "decimal" => :decimal,
+        "numeric" => :decimal,
+        "float" => :float,
+        "double" => :float,
+        "date" => :date,
+        "datetime" => :datetime,
+        "timestamp" => :datetime,
+        "time" => :time,
+        "json" => :json,
+      }.freeze
+
+      # MySQL has no boolean type: `BOOLEAN` is an alias for `TINYINT(1)`, and
+      # the display width is the only trace of the distinction left in the
+      # catalog. Mapping it to :boolean (as every MySQL ORM does) is what makes
+      # a flag column mask to false / to its own default rather than to 0.
+      BOOLEAN_COLUMN_TYPE = "tinyint(1)"
+
+      # A default MySQL evaluates per row rather than storing as a literal.
+      # `extra` carries DEFAULT_GENERATED for an expression default, but only on
+      # servers new enough to support them, so the text is screened as well: a
+      # function call, or a bare keyword such as CURRENT_TIMESTAMP, is not a
+      # value we can mask with. A literal string that happens to contain
+      # parentheses is rejected too — losing a usable default costs nothing more
+      # than falling back to the per-type constant, while accepting an
+      # expression would write a mask the database re-evaluates.
+      EXPRESSION_DEFAULT = /[()]|\Acurrent_(?:timestamp|date|time)\z|\Alocaltime(?:stamp)?\z/i
+
+      def table_names
+        rows(<<~SQL).map { |row| row[0] }.sort
+          SELECT table_name
+          FROM information_schema.tables
+          WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'
+        SQL
+      end
+
+      def primary_key(table_name)
+        names = rows(<<~SQL).map { |row| row[0] }
+          SELECT column_name
+          FROM information_schema.key_column_usage
+          WHERE table_schema = DATABASE()
+            AND table_name = #{quote(table_name)}
+            AND constraint_name = 'PRIMARY'
+          ORDER BY ordinal_position
+        SQL
+
+        case names.size
+        when 0 then nil
+        when 1 then names.first
+        else names
+        end
+      end
+
+      def columns(table_name)
+        sql = <<~SQL
+          SELECT column_name, data_type, column_type, character_maximum_length, column_default, extra
+          FROM information_schema.columns
+          WHERE table_schema = DATABASE() AND table_name = #{quote(table_name)}
+          ORDER BY ordinal_position
+        SQL
+
+        rows(sql).map do |name, data_type, column_type, character_maximum_length, column_default, extra|
+          type = column_type == BOOLEAN_COLUMN_TYPE ? :boolean : TYPE_MAP[data_type]
+          Column.new(
+            name: name,
+            type: type,
+            limit: character_maximum_length&.to_i,
+            # MySQL has no array column type; a multi-valued column is JSON,
+            # which is masked as JSON rather than as an array.
+            array: false,
+            default: coerce_default(type, literal_default(column_default, extra)),
+          )
+        end
+      end
+
+      def unique_column_names(table_name)
+        rows(<<~SQL).map { |row| row[0] }.to_set
+          SELECT DISTINCT column_name
+          FROM information_schema.statistics
+          WHERE table_schema = DATABASE()
+            AND table_name = #{quote(table_name)}
+            AND non_unique = 0
+        SQL
+      rescue StandardError => e
+        warn_once(
+          :unique_column_names,
+          "exwiw: could not read the indexes of '#{table_name}' (#{e.class}); " \
+          "treating every column as unique-indexed so no constant mask is emitted.",
+        )
+        nil
+      end
+
+      def foreign_keys(table_name)
+        # `referenced_table_name IS NOT NULL` is what distinguishes a foreign
+        # key's rows from the primary/unique key rows sharing this view.
+        build_foreign_keys(table_name, rows(<<~SQL))
+          SELECT constraint_name, column_name, referenced_table_name
+          FROM information_schema.key_column_usage
+          WHERE table_schema = DATABASE()
+            AND table_name = #{quote(table_name)}
+            AND referenced_table_name IS NOT NULL
+          ORDER BY constraint_name, ordinal_position
+        SQL
+      end
+
+      # The catalog's `column_default` as a plain literal, or nil when it is
+      # absent or is an expression (see EXPRESSION_DEFAULT).
+      private def literal_default(column_default, extra)
+        return nil if column_default.nil?
+        return nil if extra.to_s.upcase.include?("DEFAULT_GENERATED")
+        return nil if column_default.match?(EXPRESSION_DEFAULT)
+
+        column_default
+      end
+
+      private def rows(sql)
+        connection.query(sql).rows
+      end
+
+      # Table names reaching this class come from `table_names` (the catalog
+      # itself), so they cannot carry an injection; quoting is defensive, for
+      # the day a caller passes a name from elsewhere.
+      private def quote(value)
+        "'#{value.to_s.gsub("\\", "\\\\\\\\").gsub("'", "''")}'"
+      end
+
+      private def connection
+        @connection ||= Adapter::MysqlClient.new(@connection_config)
+      end
+    end
+  end
+end

data/lib/exwiw/db_introspector/postgresql_introspector.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Exwiw
+  module DbIntrospector
+    # Reads PostgreSQL's catalog, scoped to `current_schema()` — the first
+    # schema on the connection's search_path, which is the one an unqualified
+    # table name in the dump resolves to.
+    #
+    # `information_schema` is used where it is unambiguous (tables, columns,
+    # primary keys); unique indexes and foreign keys go through `pg_catalog`
+    # instead. information_schema only lists what a *constraint* declares, so a
+    # bare `CREATE UNIQUE INDEX` would be invisible there, and its
+    # `constraint_column_usage` join multiplies the rows of a composite foreign
+    # key into a cross product that cannot be grouped back.
+    class PostgresqlIntrospector < Base
+      # PostgreSQL data_type (information_schema's spelling) -> the
+      # ActiveRecord-ish symbol DefaultMask understands. An unmapped type stays
+      # nil so no mask is emitted: 'USER-DEFINED' covers every enum and
+      # extension type, where the set of valid values is per-column, and
+      # bytea/uuid/inet/interval have no constant that is safe to write back.
+      TYPE_MAP = {
+        "character" => :string,
+        "character varying" => :string,
+        "text" => :text,
+        "smallint" => :integer,
+        "integer" => :integer,
+        "bigint" => :integer,
+        "numeric" => :decimal,
+        "decimal" => :decimal,
+        "real" => :float,
+        "double precision" => :float,
+        "boolean" => :boolean,
+        "date" => :date,
+        "timestamp without time zone" => :datetime,
+        "timestamp with time zone" => :datetime,
+        "time without time zone" => :time,
+        "time with time zone" => :time,
+        "json" => :json,
+        "jsonb" => :jsonb,
+      }.freeze
+
+      # An ARRAY column reports data_type 'ARRAY' and carries the element type
+      # in udt_name, prefixed with an underscore (`_int4`). The element type is
+      # mapped so the column is still described accurately, even though
+      # DefaultMask emits no mask for an array either way.
+      ARRAY_DATA_TYPE = "ARRAY"
+      ELEMENT_TYPE_MAP = {
+        "bpchar" => :string,
+        "varchar" => :string,
+        "text" => :text,
+        "int2" => :integer,
+        "int4" => :integer,
+        "int8" => :integer,
+        "numeric" => :decimal,
+        "float4" => :float,
+        "float8" => :float,
+        "bool" => :boolean,
+        "date" => :date,
+        "timestamp" => :datetime,
+        "timestamptz" => :datetime,
+        "time" => :time,
+        "timetz" => :time,
+        "json" => :json,
+        "jsonb" => :jsonb,
+      }.freeze
+
+      # PostgreSQL renders a stored default back as the SQL text that produced
+      # it, so a plain literal arrives with its cast attached
+      # (`'member'::user_role`, `0`, `true`) and a computed one as the call that
+      # computes it (`now()`, `nextval('...')`). Only the literal forms are
+      # recognized, and the cast is stripped: matching what a mask may be built
+      # from, rather than trying to exclude every expression, keeps an
+      # unfamiliar expression on the safe side of the line.
+      QUOTED_LITERAL = /\A'((?:[^']|'')*)'(?:::[^']+)?\z/
+      NUMERIC_LITERAL = /\A-?\d+(?:\.\d+)?\z/
+      BOOLEAN_LITERAL = /\A(?:true|false)\z/i
+
+      def table_names
+        rows(<<~SQL).map { |row| row[0] }.sort
+          SELECT table_name
+          FROM information_schema.tables
+          WHERE table_schema = current_schema() AND table_type = 'BASE TABLE'
+        SQL
+      end
+
+      def primary_key(table_name)
+        names = rows(<<~SQL, [table_name]).map { |row| row[0] }
+          SELECT kcu.column_name
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON kcu.constraint_name = tc.constraint_name
+           AND kcu.constraint_schema = tc.constraint_schema
+           AND kcu.table_name = tc.table_name
+          WHERE tc.constraint_type = 'PRIMARY KEY'
+            AND tc.table_schema = current_schema()
+            AND tc.table_name = $1
+          ORDER BY kcu.ordinal_position
+        SQL
+
+        case names.size
+        when 0 then nil
+        when 1 then names.first
+        else names
+        end
+      end
+
+      def columns(table_name)
+        sql = <<~SQL
+          SELECT column_name, data_type, udt_name, character_maximum_length, column_default
+          FROM information_schema.columns
+          WHERE table_schema = current_schema() AND table_name = $1
+          ORDER BY ordinal_position
+        SQL
+
+        rows(sql, [table_name]).map do |name, data_type, udt_name, character_maximum_length, column_default|
+          array = data_type == ARRAY_DATA_TYPE
+          type = array ? ELEMENT_TYPE_MAP[udt_name.to_s.delete_prefix("_")] : TYPE_MAP[data_type]
+          Column.new(
+            name: name,
+            type: type,
+            limit: character_maximum_length&.to_i,
+            array: array,
+            default: coerce_default(type, literal_default(column_default)),
+          )
+        end
+      end
+
+      def unique_column_names(table_name)
+        # `attnum = ANY(indkey)` keeps an expression index out of the result on
+        # its own: its entries are recorded as attnum 0, which no real column
+        # has, so the index simply contributes nothing.
+        rows(<<~SQL, [table_name]).map { |row| row[0] }.to_set
+          SELECT att.attname
+          FROM pg_index i
+          JOIN pg_class rel ON rel.oid = i.indrelid
+          JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+          JOIN pg_attribute att ON att.attrelid = rel.oid AND att.attnum = ANY(i.indkey)
+          WHERE i.indisunique
+            AND nsp.nspname = current_schema()
+            AND rel.relname = $1
+        SQL
+      rescue StandardError => e
+        warn_once(
+          :unique_column_names,
+          "exwiw: could not read the indexes of '#{table_name}' (#{e.class}); " \
+          "treating every column as unique-indexed so no constant mask is emitted.",
+        )
+        nil
+      end
+
+      def foreign_keys(table_name)
+        # `conkey` lists the constrained columns in key order; unnesting it WITH
+        # ORDINALITY yields the one-row-per-key-column shape build_foreign_keys
+        # groups, so a composite constraint stays recognizable as one.
+        build_foreign_keys(table_name, rows(<<~SQL, [table_name]))
+          SELECT con.conname, att.attname, ref.relname
+          FROM pg_constraint con
+          JOIN pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+          JOIN pg_class ref ON ref.oid = con.confrelid
+          JOIN unnest(con.conkey) WITH ORDINALITY AS u(attnum, ord) ON TRUE
+          JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = u.attnum
+          WHERE con.contype = 'f'
+            AND nsp.nspname = current_schema()
+            AND rel.relname = $1
+          ORDER BY con.conname, u.ord
+        SQL
+      end
+
+      # The catalog's `column_default` as a plain literal, or nil when it is
+      # absent or is an expression (see QUOTED_LITERAL and friends).
+      private def literal_default(column_default)
+        return nil if column_default.nil?
+
+        if (match = QUOTED_LITERAL.match(column_default))
+          # Inside a SQL string literal a quote is doubled; undouble it so the
+          # mask is the value the column actually defaults to.
+          return match[1].gsub("''", "'")
+        end
+        return column_default if column_default.match?(NUMERIC_LITERAL)
+        return column_default.downcase if column_default.match?(BOOLEAN_LITERAL)
+
+        nil
+      end
+
+      private def rows(sql, params = nil)
+        params.nil? ? connection.exec(sql).values : connection.exec_params(sql, params).values
+      end
+
+      private def connection
+        @connection ||= begin
+          require_driver!
+          PG.connect(
+            host: @connection_config.host,
+            port: @connection_config.port,
+            user: @connection_config.user,
+            password: @connection_config.password,
+            dbname: @connection_config.database_name,
+          )
+        end
+      end
+
+      # Soft-require the driver, like MysqlClient does, so a host that only ever
+      # runs the MySQL path is not forced to build the pg gem — and so the
+      # failure names the gem to install instead of surfacing a bare LoadError.
+      private def require_driver!
+        require "pg"
+      rescue LoadError
+        raise LoadError,
+              "exwiw needs the 'pg' gem to connect to PostgreSQL. " \
+              "Add `gem \"pg\"` to your Gemfile."
+      end
+    end
+  end
+end