rails-ai-context 5.35.0 → 5.35.2

data/lib/rails_ai_context/cli/tool_runner.rb

@@ -25,13 +25,16 @@ module RailsAiContext
       attr_reader :tool_class, :raw_args, :json_mode, :error
 
       def initialize(tool_name, raw_args, json_mode: false, environment: nil)
-        @tool_class = resolve_tool(tool_name)
+        RunCache.around do
+          @custom_tools = Server.resolve_custom_tools
+          @tool_class, @retired = resolve_tool(tool_name)
+        end
         @raw_args = raw_args
         @json_mode = json_mode
         @environment = environment
         @error = false
         @missing_required = false
-        @invalid_required = []
+        @refused = []
         @out_of_type = {}
         # How each param was typed, so a suggestion uses the same form.
         @flag_spellings = {}
@@ -43,20 +46,28 @@ module RailsAiContext
       # announced its Redis connection on stdout ahead of a --json envelope.
       def run
         OutputGuard.quarantine_stdout(across_exec: false) do
-          kwargs = build_kwargs
-          schema = tool_schema
-          validate_kwargs!(kwargs, schema)
-          next extract_output(invalid_required_response) if @invalid_required.any?
-
-          response = tool_class.call(**kwargs)
-          extract_output(response)
+          Server.with_custom_tools(@custom_tools) do
+            kwargs = build_kwargs
+            schema = tool_schema
+            validate_kwargs!(kwargs, schema)
+            next extract_output(refusal_response) if @refused.any?
+
+            response = tool_class.call(**kwargs)
+            response = Tools::GetConfig.with_retired_note(response, @retired, kwargs) if @retired
+            extract_output(response)
+          end
         end
       end
 
+      # The tool's help, or for a retired name its config section's.
+      def help
+        self.class.tool_help(tool_class, @retired)
+      end
+
       # List all available tools with short names and descriptions.
       def self.tool_list
         lines = [ "Available tools:", "" ]
-        available_tools.each do |tool|
+        Server.exposed_tools.each do |tool|
           short = short_name(tool.tool_name)
           full = tool.description_value.to_s
           desc = full.truncate(79, separator: " ", omission: "...")
@@ -82,30 +93,25 @@ module RailsAiContext
         lines.join("\n")
       end
 
-      # Filtered tool list respecting skip_tools config.
-      # The MCP server's rule: skip_tools removes built-ins only, and a built-in
-      # comes before a custom tool of the same name, so skip_tools is how a
-      # custom tool replaces one.
-      def self.available_tools
-        skip = RailsAiContext.configuration.skip_tools
-        Server.builtin_tools.reject { |t| skip.include?(t.tool_name) } + Server.resolve_custom_tools
-      end
-
-      # Generate help for a specific tool from its input_schema.
-      def self.tool_help(tool_class)
-        schema = tool_class.input_schema_value&.to_h || {}
+      # Generate help for a specific tool from its input_schema. A retired
+      # name gets its own section's parameters, read from rails_get_config.
+      def self.tool_help(tool_class, retired = nil)
+        schema = retired ? Tools::GetConfig.schema_for([ retired ]) : tool_class.input_schema_value&.to_h || {}
         properties = schema[:properties] || {}
-        required = schema[:required] || []
+        properties = properties.except(:section) if retired
+        required = retired ? [] : schema[:required] || []
+        name = retired ? retired.tool_name : tool_class.tool_name
+        about = retired ? "runs the `#{retired.name}` section of rails_get_config (#{retired.summary})." : tool_class.description_value
 
         lines = [
-          "#{tool_class.tool_name} - #{tool_class.description_value}",
+          "#{name} - #{about}",
           "",
           "Usage:"
         ]
         # Standalone installs have no rake tasks; only show the rake form when
         # the gem lives in an app's Gemfile, not at an engine's root.
         form = RailsAiContext::InstallMode.form
-        short = short_name(tool_class.tool_name)
+        short = short_name(name)
         if form == :tasks
           lines << "  rails 'ai:tool[#{short}]' #{properties.keys.map { |k| "#{k}=VALUE" }.join(' ')}"
         end
@@ -135,59 +141,48 @@ module RailsAiContext
         tool_name.sub(/\Arails_get_/, "").sub(/\Arails_/, "")
       end
 
+      # The full names a typed name can spell: `schema`, `get_schema` and `rails_get_schema` are one tool.
+      def self.candidate_names(name)
+        [ name, "rails_#{name}", "rails_get_#{name}" ]
+      end
+
       private
 
-      # InputSchema#to_h is stable across the mcp gem's >= 0.13, < 2.0 range;
-      # the older #schema accessor was removed in mcp 0.20.0. to_h returns a
-      # symbol-keyed hash carrying the :properties and :required this runner
-      # reads (newer mcp also merges a benign :$schema key we ignore).
+      # The schema a call is checked against, as InputSchema#to_h gives it on every
+      # supported mcp. rails_get_config's takes a section skip_tools turned off.
       def tool_schema
-        tool_class.input_schema_value&.to_h || {}
+        tool_class.input_schema&.to_h || {}
       end
 
-      # The tool a name spells, loading that one class rather than all 45, in
-      # available_tools' order: an unskipped built-in, then a custom tool. A
-      # miss falls back to the full list, which also carries the suggestion.
+      # The tool a name spells and the config section a retired name stands for, loading
+      # that one class and no other. A miss falls back to the full list for the suggestion.
       def direct_tool(name)
-        skip = RailsAiContext.configuration.skip_tools
-        custom = Server.resolve_custom_tools
-        [ name, "rails_#{name}", "rails_get_#{name}" ].each do |candidate|
-          found = (builtin_tool(candidate) unless skip.include?(candidate)) ||
-                  custom.find { |tool| tool.tool_name == candidate }
-          return found if found
+        self.class.candidate_names(name).each do |candidate|
+          found = Server.served_tool(candidate)
+          next unless found
+
+          # A retired config tool name runs its section, as the MCP server does.
+          section = Tools::GetConfig.retired_section(candidate)
+          return section && found.equal?(section.renderer) ? [ Tools::GetConfig, section ] : [ found, nil ]
         end
         nil
       end
 
-      def builtin_tool(tool_name)
-        const = tool_name.delete_prefix("rails_").split("_").map(&:capitalize).join
-        return nil unless const.match?(/\A[A-Z]\w*\z/) && Tools.const_defined?(const, false)
-
-        tool = Tools.const_get(const, false)
-        tool if tool.is_a?(Class) && tool < Tools::BaseTool && !tool.abstract? && tool.tool_name == tool_name
-      end
-
       # Resolve tool name: tries short → medium → full form.
       # "schema" → "rails_get_schema", "search_code" → "rails_search_code"
       def resolve_tool(name)
         direct = direct_tool(name)
         return direct if direct
 
-        tools = self.class.available_tools
-
-        [ name, "rails_#{name}", "rails_get_#{name}" ].each do |candidate|
-          found = tools.find { |t| t.tool_name == candidate }
-          return found if found
-        end
-
+        tools = Server.exposed_tools
         found = tools.find { |t| self.class.short_name(t.tool_name) == name }
-        return found if found
+        return [ found, nil ] if found
 
-        skipped = [ name, "rails_#{name}", "rails_get_#{name}" ].find { |candidate| Server.skipped_tools.include?(candidate) }
-        raise ToolNotFoundError, Server.skipped_tool_message(skipped) if skipped
+        skipped = self.class.candidate_names(name) & Server.skipped_tools
+        raise ToolNotFoundError, Server.skipped_tool_message(skipped.first) if skipped.any?
 
         # Fuzzy suggestion
-        short_names = tools.map { |t| self.class.short_name(t.tool_name) }
+        short_names = (tools.map(&:tool_name) | Server.retired_names).map { |tool_name| self.class.short_name(tool_name) }
         suggestion = Tools::BaseTool.find_closest_match(name, short_names)
         msg = "Unknown tool '#{name}'."
         msg += " Did you mean '#{suggestion}'?" if suggestion
@@ -209,7 +204,7 @@ module RailsAiContext
         when Hash
                    raw_args.transform_keys(&:to_sym).except(:server_context).transform_values { |value| utf8(value) }
         when Array
-                   return with_environment(parse_cli_args(raw_args).except(:server_context))
+                   return with_environment(with_section(parse_cli_args(raw_args).except(:server_context)))
         else
                    {}
         end
@@ -221,7 +216,11 @@ module RailsAiContext
           kwargs[key] = coerce_value(value, prop, key)
         end
 
-        with_environment(kwargs)
+        with_environment(with_section(kwargs))
+      end
+
+      def with_section(kwargs)
+        @retired ? kwargs.merge(section: @retired.name) : kwargs
       end
 
       # `--environment` sets RAILS_ENV, so it never arrives as a tool argument; a tool that
@@ -229,10 +228,16 @@ module RailsAiContext
       def with_environment(kwargs)
         return kwargs if @environment.nil? || kwargs.key?(:environment)
         return kwargs unless (tool_schema[:properties] || {}).key?(:environment)
+        # Only a section that reads it gets it; the others answer for RAILS_ENV.
+        return kwargs if tool_class == Tools::GetConfig && !section_reads_environment?(kwargs[:section])
 
         kwargs.merge(environment: @environment)
       end
 
+      def section_reads_environment?(name)
+        Tools::GetConfig.section_named(name || "app")&.params&.include?(:environment)
+      end
+
       # Parse ["--table", "users", "--detail", "full", "--app-only"] into { table: "users", ... }
       def parse_cli_args(args)
         args = args.map { |arg| utf8(arg) }
@@ -246,7 +251,10 @@ module RailsAiContext
           if arg.start_with?("--no-")
             key = arg.sub("--no-", "").tr("-", "_").to_sym
             @flag_spellings[key] = arg
-            result[key] = false
+            type = properties.dig(key, :type)
+            # Only a boolean has a false; an unknown flag passes through for the unknown-param message.
+            @out_of_type[key] = arg if type && type != "boolean" && key != :detail
+            result[key] = @out_of_type.key?(key) ? nil : false
             i += 1
           elsif arg.start_with?("--")
             if arg.include?("=")
@@ -341,16 +349,15 @@ module RailsAiContext
         end
       end
 
-      # The flag a stray word was most likely meant for: a required param
-      # first, since that is the one a caller must supply.
+      # The flag a stray word was most likely meant for, among the ones
+      # offered: a required param first, since a caller must supply it.
       def suggested_flag
-        schema = tool_schema
-        properties = (schema[:properties] || {})
-        return nil if properties.empty?
+        offered = offered_params
+        return nil if offered.empty?
 
-        required = (schema[:required] || []).map(&:to_s)
-        name = properties.keys.find { |k| required.include?(k.to_s) } || properties.keys.first
-        "--#{name.to_s.tr('_', '-')}"
+        required = (tool_schema[:required] || []).map(&:to_s)
+        name = offered.find { |param| required.include?(param) } || offered.first
+        "--#{name.tr('_', '-')}"
       end
 
       # A suggested param in the form the unknown one was typed: `--table`
@@ -360,10 +367,15 @@ module RailsAiContext
       end
 
       def valid_params_line
-        keys = (tool_schema[:properties] || {}).keys.map(&:to_s)
+        keys = offered_params
         keys.any? ? "Valid params: #{keys.join(', ')}" : "This tool takes no params."
       end
 
+      # The parameters to name to the caller: the ones tools/list shows, or a retired name's own section's.
+      def offered_params
+        @retired ? @retired.params.map(&:to_s) : Tools::SafeCall.published_params(tool_class)
+      end
+
       def stray_argument_message(arg)
         flag = suggested_flag
         hint = flag ? " - did you mean '#{flag} #{arg}'?" : ""
@@ -394,21 +406,21 @@ module RailsAiContext
         [ tokens.flat_map { |a| Array(coerce_value(a, { type: "array" })) }, tokens.size ]
       end
 
-      # Coerce a string value to the type specified in the JSON Schema property.
+      # Coerce a string value to its JSON Schema type. One of another type (`--limit abc`, `app_only=maybe`)
+      # is recorded for validation to refuse: coerced to 0 or false it answers a question nobody asked.
       def coerce_value(raw, property_schema, key = nil)
         case property_schema[:type]
         when "integer"
-          # `--limit abc` is 0 through `to_i`, which answers a question
-          # nobody asked. Record it instead, so validation refuses it the way
-          # an out-of-enum value is refused.
-          if raw.is_a?(Integer) || raw.to_s.strip.match?(/\A[-+]?\d+\z/)
-            raw.to_i
-          else
-            @out_of_type[key] = raw if key
-            nil
-          end
+          return raw.to_i if raw.is_a?(Integer) || raw.to_s.strip.match?(/\A[-+]?\d+\z/)
+
+          @out_of_type[key] = raw if key
+          nil
         when "boolean"
-          TRUTHY_WORDS.include?(raw.to_s.downcase)
+          return raw if raw == true || raw == false
+          return TRUTHY_WORDS.include?(raw.to_s.downcase) if BOOLEAN_WORDS.include?(raw.to_s.downcase)
+
+          @out_of_type[key] = raw if key
+          nil
         when "array"
           raw.is_a?(Array) ? raw : raw.to_s.split(",").map(&:strip)
         else
@@ -419,12 +431,13 @@ module RailsAiContext
       # Validate kwargs against the tool's input_schema.
       # For missing required params: strip empty values so the tool's own guards
       # can return a friendly response (matching MCP behavior).
-      # For invalid enums: strip the bad value and let the tool use its default.
+      # For a value the parameter cannot take, by type or by list: refuse the call, except
+      # `detail`, which falls back with a warning.
       # For unknown params: raise InvalidArgumentError with closest-match suggestion.
       def validate_kwargs!(kwargs, schema)
         properties = schema[:properties] || {}
         required = (schema[:required] || []).map(&:to_s)
-        known_keys = properties.keys.map(&:to_s)
+        known_keys = offered_params
 
         # Check for unknown params and raise a helpful error with suggestions.
         # server_context is always allowed (internal MCP param).
@@ -438,12 +451,9 @@ module RailsAiContext
           raise InvalidArgumentError, "Unknown param#{unknown.size > 1 ? 's' : ''}:\n#{msgs.join("\n")}\n#{valid_params_line}"
         end
 
-        # A value the schema's type cannot hold is dropped with a warning, the
-        # same treatment an out-of-enum value gets, so the tool applies its own
-        # default rather than the zero `to_i` would invent.
         @out_of_type.each do |key, raw|
-          prop = properties[key] || {}
-          $stderr.puts "Warning: '#{raw}' is not a valid value for #{key}. Expected #{prop[:type]}. Using default."
+          type = properties.dig(key, :type)
+          refuse(key, raw, type == "boolean" ? "true or false" : properties.dig(key, :enum)&.join(", ") || "#{article(type)} #{type}")
           kwargs.delete(key)
         end
 
@@ -460,10 +470,8 @@ module RailsAiContext
           @missing_required = true
         end
 
-        # Check enum constraints - downcase before comparing for case-insensitive match.
-        # If invalid, strip the param so the tool uses its default behavior; a
-        # required one has no default, so the call answers with the error itself
-        # rather than letting the tool report the value as missing.
+        # A value outside the list answers another question, so the call is refused;
+        # every `detail` level answers the same one, so that falls back.
         kwargs.each do |key, value|
           prop = properties[key]
           next unless prop&.dig(:enum)
@@ -477,20 +485,23 @@ module RailsAiContext
             kwargs[key] = matched
           else
             valid = prop[:enum].join(", ")
-            if required.include?(key.to_s)
-              @invalid_required << "**Error:** `#{value}` is not a valid `#{key}`. Valid: #{valid}"
-              @missing_required = true
-            else
+            if key == :detail
               $stderr.puts "Warning: '#{value}' is not a valid value for #{key}. Valid: #{valid}. Using default."
               kwargs.delete(key)
+            else
+              refuse(key, value, valid)
             end
           end
         end
       end
 
+      def refuse(key, value, valid)
+        @refused << "**Error:** `#{value}` is not a valid `#{key}`. Valid: #{valid}"
+      end
+
       # Through the tool's own wrapper when it has one, so the static-tier banner rides along.
-      def invalid_required_response
-        text = @invalid_required.join("\n")
+      def refusal_response
+        text = @refused.join("\n")
         return tool_class.text_response(text) if tool_class <= Tools::BaseTool
 
         MCP::Tool::Response.new([ { type: "text", text: text } ])
@@ -508,7 +519,7 @@ module RailsAiContext
       # reported failure (isError), so callers can set a non-zero exit code.
       def extract_output(response)
         text = response.content.first&.dig(:text) || ""
-        @error = @missing_required || (response.respond_to?(:error?) && response.error?)
+        @error = @missing_required || @refused.any? || (response.respond_to?(:error?) && response.error?)
         if json_mode
           require "json"
           JSON.pretty_generate(tool: tool_class.tool_name, output: text, error: @error)

data/lib/rails_ai_context/configuration.rb

@@ -50,6 +50,8 @@ module RailsAiContext
       return unless File.exist?(path)
 
       data = YAML.safe_load_file(path, permitted_classes: PERMITTED_YAML_CLASSES) || {}
+      return $stderr.puts("[rails-ai-context] WARNING: #{path}: the file holds no `key: value` settings. Ignored.") unless data.is_a?(Hash)
+
       config = RailsAiContext.configuration
 
       data.each do |key, value|
@@ -257,7 +259,7 @@ module RailsAiContext
     # metadata (method, tool_name, duration, error) is forwarded to
     # subscribers. When true, `tool_arguments` and `arguments` are forwarded
     # verbatim - including raw SQL from `rails_query`, env var names from
-    # `rails_get_env`, and log search patterns from `rails_read_logs`.
+    # `rails_get_config(section: "env")`, and log search patterns from `rails_read_logs`.
     #
     # Setting this to true means the operator takes on the redaction
     # obligation for any downstream observability pipeline (Datadog, Scout,
@@ -379,7 +381,7 @@ module RailsAiContext
     attr_accessor :extra_app_paths
 
     # Database query tool settings (rails_query)
-    attr_accessor :query_timeout              # Statement timeout in seconds (default: 5)
+    attr_reader :query_timeout                # Statement timeout in seconds, a positive number (default: 5)
     attr_reader :query_row_limit              # Max rows returned (default: 100, hard cap: 1000)
     attr_accessor :query_redacted_columns     # Column names a query may not reference, redacted in output
     attr_accessor :query_allowed_columns      # Column names to exempt from the built-in sensitive list
@@ -459,12 +461,7 @@ module RailsAiContext
       @extra_app_paths          = []
       @query_timeout            = 5
       @query_row_limit          = 100
-      @query_redacted_columns   = %w[
-        password_digest encrypted_password password_hash
-        reset_password_token confirmation_token unlock_token
-        otp_secret session_data secret_key
-        api_key api_secret access_token refresh_token jti
-      ]
+      @query_redacted_columns   = SecretColumns::DEFAULT_REDACTED_COLUMNS.dup
       @query_allowed_columns    = []
       @allow_query_in_production = false
       @log_lines                = 50
@@ -529,6 +526,16 @@ module RailsAiContext
       @max_tool_response_chars = value
     end
 
+    # A fraction of a second is kept as given: each database family rounds it up to the least it can bound.
+    def query_timeout=(value)
+      number = value.is_a?(String) ? Integer(value, exception: false) || Float(value, exception: false) : value
+      unless number.is_a?(Numeric) && number.real? && number.positive? && number.finite?
+        raise ArgumentError, "query_timeout must be positive (got #{value})"
+      end
+
+      @query_timeout = number
+    end
+
     def query_row_limit=(value)
       value = value.to_i
       raise ArgumentError, "query_row_limit must be between 1 and 1000 (got #{value})" unless value.between?(1, 1000)

data/lib/rails_ai_context/database_family/mysql_runtime.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module DatabaseFamily
+    # MySQL bounds a statement with the session max_execution_time, which also holds a WITH or EXPLAIN ANALYZE.
+    # MariaDB has no max_execution_time; its session max_statement_time does the same.
+    module MysqlRuntime
+      module_function
+
+      IN_TRANSACTION = "MySQL cannot make a transaction that is already open read-only, so the statement " \
+        "was not sent. Run it outside the transaction."
+
+      def read_only(conn, sql, timeout)
+        raise Unsupported, IN_TRANSACTION if conn.transaction_open?
+
+        result = bounded(conn, timeout) { |session| in_read_only_transaction(conn, sql, session) }
+        Rows.new(result.columns, result.rows, false)
+      end
+
+      REPLACED = "the connection was replaced before the statement was sent, and the new session has no " \
+        "read-only transaction and no time limit, so the statement was not sent"
+
+      # The statement limit does not cover SHOW, so lock_wait_timeout (whole seconds) ends a wait on a metadata lock.
+      # Both session values are put back after the block, which is given the id of the session that holds them.
+      def bounded(conn, timeout)
+        limit, value = if conn.mariadb? then [ "max_statement_time", [ timeout.to_f, 0.001 ].max ]
+        else [ "max_execution_time", [ (timeout * 1000).to_i, 1 ].max ]
+        end
+        DatabaseFamily.bounding do
+          previous = conn.select_rows("SELECT @@SESSION.#{limit}, @@SESSION.lock_wait_timeout, CONNECTION_ID()").first
+          begin
+            conn.execute("SET SESSION #{limit} = #{value}, lock_wait_timeout = #{[ timeout.ceil, 1 ].max}")
+            yield previous[2]
+          ensure
+            DatabaseFamily.restore(conn, "SET SESSION #{limit} = #{previous[0]}, lock_wait_timeout = #{previous[1]}")
+          end
+        end
+      end
+
+      # MySQL rejects SET TRANSACTION once a transaction is open, and Rails opens the lazy BEGIN
+      # before the first statement in the block. Unscoped, it applies to the next transaction only.
+      def in_read_only_transaction(conn, sql, session)
+        result = nil
+        conn.execute("SET TRANSACTION READ ONLY")
+        conn.transaction do
+          # Rails replaces a connection it lost before BEGIN, and a new session has neither guard.
+          raise ActiveRecord::ConnectionNotEstablished, REPLACED unless conn.select_value("SELECT CONNECTION_ID()").to_i == session.to_i
+
+          result = conn.select_all(sql)
+          raise ActiveRecord::Rollback
+        end
+        result
+      end
+
+      def explain(conn, sql, timeout)
+        # MySQL 8.3+ defaults to TREE output, which has no table/type/key columns. MariaDB has no FORMAT=TRADITIONAL.
+        prefix = conn.mariadb? ? "EXPLAIN" : "EXPLAIN FORMAT=TRADITIONAL"
+        result = read_only(conn, "#{prefix} #{sql}", timeout)
+        scans = []
+        warnings = []
+        raw_lines = result.rows.map do |row|
+          cols = result.columns.zip(row).to_h
+          table = cols["table"]
+          rows = cols["rows"].to_i
+          extra = cols["Extra"].to_s
+          # A row with no table ("No tables used") scans nothing.
+          if table
+            scans << { table: table, type: scan_label(cols["type"]), index: cols["key"] }
+            warnings << "Full table scan on #{table} (#{rows} rows)" if cols["type"] == "ALL" && rows > 1000
+            warnings << "Using filesort on #{table}" if extra.include?("filesort")
+            warnings << "Using temporary table on #{table}" if extra.include?("temporary")
+          end
+          cols.map { |k, v| "#{k}: #{v}" }.join(", ")
+        end
+        { scan_types: scans, warnings: warnings, raw: raw_lines.join("\n"), unbounded: false }
+      end
+
+      def scan_label(type)
+        case type
+        when "ALL" then "full table scan"
+        when "index" then "full index scan"
+        when "range" then "index range scan"
+        when "ref", "eq_ref" then "index lookup"
+        when "const", "system" then "constant lookup"
+        else type.to_s
+        end
+      end
+
+      def column_sources(_conn, _sql, _plan)
+        []
+      end
+
+      def plan(_conn, _sql, _timeout)
+        nil
+      end
+
+      # The schemas no secret column rule reads: their relations are refused by name or hold no app data.
+      SYSTEM_SCHEMAS = %w[mysql sys performance_schema information_schema].freeze
+
+      def unqualified_schemas(_conn)
+        []
+      end
+
+      # Compared by the server, so a name matches a schema as a statement's own reference would.
+      def schemas_named(conn, names)
+        conn.select_values(
+          "SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME IN (#{quoted(conn, names)}) " \
+          "AND SCHEMA_NAME NOT IN (#{quoted(conn, SYSTEM_SCHEMAS)}) AND SCHEMA_NAME <> DATABASE()"
+        )
+      end
+
+      def quoted(conn, names)
+        names.map { |name| conn.quote(name) }.join(", ")
+      end
+
+      def in_schemas(conn, column, schemas)
+        schemas.empty? ? "#{column} = DATABASE()" : "#{column} IN (#{quoted(conn, schemas)})"
+      end
+
+      def relation_columns(conn, schemas = [])
+        DatabaseFamily.by_table(conn.select_rows(
+          "SELECT c.TABLE_NAME, c.COLUMN_NAME FROM information_schema.COLUMNS c JOIN information_schema.TABLES t " \
+          "ON t.TABLE_SCHEMA = c.TABLE_SCHEMA AND t.TABLE_NAME = c.TABLE_NAME " \
+          "WHERE #{in_schemas(conn, "c.TABLE_SCHEMA", schemas)} AND t.TABLE_TYPE = 'BASE TABLE' ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION"
+        )).transform_values(&:flatten)
+      end
+
+      # The definition is empty for a view the account may not SHOW.
+      def view_definitions(conn, schemas = [])
+        DatabaseFamily.by_view(conn.select_rows(
+          "SELECT TABLE_NAME, VIEW_DEFINITION FROM information_schema.VIEWS WHERE #{in_schemas(conn, "TABLE_SCHEMA", schemas)}"
+        ))
+      end
+
+      def traced_views(_conn, _schemas = [])
+        []
+      end
+
+      def generated_columns(conn, schemas = [])
+        DatabaseFamily.keep_expressions({}, conn.select_rows(
+          "SELECT TABLE_NAME, COLUMN_NAME, GENERATION_EXPRESSION FROM information_schema.COLUMNS " \
+          "WHERE #{in_schemas(conn, "TABLE_SCHEMA", schemas)} AND GENERATION_EXPRESSION <> ''"
+        ))
+      end
+
+      def index_tables(_conn, _schemas = [])
+        {}
+      end
+
+      # Base tables only: a view has no rows or bytes of its own.
+      BASE_TABLES = "FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'"
+
+      def table_sizes(conn)
+        conn.select_all("SELECT TABLE_NAME AS name, (DATA_LENGTH + INDEX_LENGTH) AS bytes #{BASE_TABLES}")
+          .map { |r| { name: r["name"], bytes: r["bytes"].to_i } }
+          .sort_by { |r| [ -r[:bytes], r[:name] ] }
+      end
+
+      def row_estimates(conn)
+        conn.select_all("SELECT TABLE_NAME AS table_name, TABLE_ROWS AS approximate_row_count #{BASE_TABLES}")
+          .map { |r| { table: r["table_name"], approximate_rows: r["approximate_row_count"].to_i } }
+          .sort_by { |t| [ -t[:approximate_rows], t[:table] ] }
+      end
+
+      def index_usage(_conn)
+        nil
+      end
+    end
+  end
+end