rdbr 0.1.0

data/lib/rdbr/catalog/mysql/queries.rb

@@ -0,0 +1,131 @@
+module RDBr
+  module Catalog
+    class MysqlQueries
+      SYSTEM_SCHEMAS = %w[information_schema mysql performance_schema sys].freeze
+      DATABASE_SQL = '/* rdbr: mysql database */ SELECT DATABASE() AS name'.freeze
+      NAMESPACES_SQL = <<~SQL.freeze
+        /* rdbr: mysql namespaces */
+        SELECT SCHEMA_NAME AS name
+        FROM information_schema.SCHEMATA
+        %<system_filter>s
+        ORDER BY SCHEMA_NAME
+      SQL
+      RELATIONS_SQL = <<~SQL.freeze
+        /* rdbr: mysql relations */
+        SELECT TABLE_SCHEMA AS namespace_name, TABLE_NAME AS relation_name,
+               TABLE_TYPE AS relation_kind, TABLE_COMMENT AS comment
+        FROM information_schema.TABLES
+        WHERE TABLE_TYPE IN ('BASE TABLE', 'VIEW', 'SYSTEM VIEW')
+          %<system_filter>s
+        ORDER BY TABLE_SCHEMA, TABLE_NAME
+      SQL
+      COLUMNS_SQL = <<~SQL.freeze
+        /* rdbr: mysql columns */
+        SELECT COLUMN_NAME AS name, DATA_TYPE AS logical_type, COLUMN_TYPE AS sql_type,
+               IS_NULLABLE AS nullable, COLUMN_DEFAULT AS default_expression,
+               GENERATION_EXPRESSION AS generated_expression, EXTRA AS extra,
+               ORDINAL_POSITION AS ordinal
+        FROM information_schema.COLUMNS
+        WHERE TABLE_SCHEMA = %<namespace>s AND TABLE_NAME = %<relation>s
+        ORDER BY ORDINAL_POSITION
+      SQL
+      CONSTRAINTS_SQL = <<~SQL.freeze
+        /* rdbr: mysql constraints */
+        SELECT constraint_record.CONSTRAINT_NAME AS name,
+               constraint_record.CONSTRAINT_TYPE AS constraint_type,
+               key_column.COLUMN_NAME AS column_name,
+               key_column.ORDINAL_POSITION AS ordinal,
+               key_column.REFERENCED_TABLE_SCHEMA AS referenced_namespace,
+               key_column.REFERENCED_TABLE_NAME AS referenced_relation,
+               key_column.REFERENCED_COLUMN_NAME AS referenced_column,
+               reference.UPDATE_RULE AS on_update, reference.DELETE_RULE AS on_delete
+        FROM information_schema.TABLE_CONSTRAINTS constraint_record
+        LEFT JOIN information_schema.KEY_COLUMN_USAGE key_column
+          ON key_column.CONSTRAINT_SCHEMA = constraint_record.CONSTRAINT_SCHEMA
+         AND key_column.TABLE_NAME = constraint_record.TABLE_NAME
+         AND key_column.CONSTRAINT_NAME = constraint_record.CONSTRAINT_NAME
+        LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS reference
+          ON reference.CONSTRAINT_SCHEMA = constraint_record.CONSTRAINT_SCHEMA
+         AND reference.TABLE_NAME = constraint_record.TABLE_NAME
+         AND reference.CONSTRAINT_NAME = constraint_record.CONSTRAINT_NAME
+        WHERE constraint_record.TABLE_SCHEMA = %<namespace>s
+          AND constraint_record.TABLE_NAME = %<relation>s
+          AND constraint_record.CONSTRAINT_TYPE IN ('PRIMARY KEY', 'UNIQUE', 'FOREIGN KEY')
+        ORDER BY constraint_record.CONSTRAINT_NAME, key_column.ORDINAL_POSITION
+      SQL
+      CHECKS_SQL = <<~SQL.freeze
+        /* rdbr: mysql checks */
+        SELECT constraint_record.CONSTRAINT_NAME AS name, check_record.CHECK_CLAUSE AS expression
+        FROM information_schema.TABLE_CONSTRAINTS constraint_record
+        INNER JOIN information_schema.CHECK_CONSTRAINTS check_record
+          ON check_record.CONSTRAINT_SCHEMA = constraint_record.CONSTRAINT_SCHEMA
+         AND check_record.CONSTRAINT_NAME = constraint_record.CONSTRAINT_NAME
+        WHERE constraint_record.TABLE_SCHEMA = %<namespace>s
+          AND constraint_record.TABLE_NAME = %<relation>s
+          AND constraint_record.CONSTRAINT_TYPE = 'CHECK'
+        ORDER BY constraint_record.CONSTRAINT_NAME
+      SQL
+      INDEXES_SQL = <<~SQL.freeze
+        /* rdbr: mysql indexes */
+        SELECT INDEX_NAME AS name, NON_UNIQUE AS non_unique, INDEX_TYPE AS index_type,
+               SEQ_IN_INDEX AS ordinal, COLUMN_NAME AS column_name
+        FROM information_schema.STATISTICS
+        WHERE TABLE_SCHEMA = %<namespace>s AND TABLE_NAME = %<relation>s
+        ORDER BY INDEX_NAME, SEQ_IN_INDEX
+      SQL
+
+      def initialize(connection, include_system: false)
+        @connection = connection
+        @include_system = include_system
+      end
+
+      def database = connection.select_all(DATABASE_SQL)
+
+      def namespaces
+        connection.select_all(format(NAMESPACES_SQL, system_filter: namespace_filter))
+      end
+
+      def relations
+        connection.select_all(format(RELATIONS_SQL, system_filter: relation_filter))
+      end
+
+      def columns(namespace, relation) = select_for(COLUMNS_SQL, namespace, relation)
+
+      def constraints(namespace, relation) = select_for(CONSTRAINTS_SQL, namespace, relation)
+
+      def checks(namespace, relation)
+        connection.select_all_optional(format_for(CHECKS_SQL, namespace, relation))
+      end
+
+      def indexes(namespace, relation) = select_for(INDEXES_SQL, namespace, relation)
+
+      private
+
+      attr_reader :connection
+
+      def select_for(sql, namespace, relation)
+        connection.select_all(format_for(sql, namespace, relation))
+      end
+
+      def format_for(sql, namespace, relation)
+        format(sql, namespace: connection.quote(namespace), relation: connection.quote(relation))
+      end
+
+      def namespace_filter
+        return '' if @include_system
+
+        "WHERE SCHEMA_NAME NOT IN (#{quoted_system_schemas})"
+      end
+
+      def relation_filter
+        return '' if @include_system
+
+        "AND TABLE_SCHEMA NOT IN (#{quoted_system_schemas})"
+      end
+
+      def quoted_system_schemas
+        SYSTEM_SCHEMAS.map{|name| connection.quote(name) }.join(', ')
+      end
+    end
+  end
+end

data/lib/rdbr/catalog/mysql.rb

@@ -0,0 +1,146 @@
+require_relative 'mysql/queries'
+
+module RDBr
+  module Catalog
+    class Mysql < Reader
+      RELATION_KINDS = { 'BASE TABLE' => :table, 'VIEW' => :view, 'SYSTEM VIEW' => :view }.freeze
+      FOREIGN_KEY_ACTIONS = {
+        'NO ACTION' => :no_action, 'RESTRICT' => :restrict, 'CASCADE' => :cascade,
+        'SET NULL' => :set_null, 'SET DEFAULT' => :set_default
+      }.freeze
+      TYPE_MAPPINGS = {
+        /bigint/ => :int8, /tinyint|smallint|mediumint/ => :int2, /int|integer/ => :int4,
+        /decimal|numeric/ => :numeric, /float/ => :float4, /double|real/ => :float8,
+        /varchar|enum|set/ => :varchar, /char/ => :char, /text/ => :text,
+        /datetime|timestamp/ => :timestamp, /date/ => :date, /time/ => :time, /year/ => :int2,
+        /bool|boolean/ => :boolean, /json/ => :json, /binary|blob/ => :blob, /geometry/ => :geometry,
+        /bit/ => :varbit
+      }.freeze
+
+      def initialize(connection, include_system: false)
+        super
+        @queries = MysqlQueries.new(connection, include_system: include_system)
+      end
+
+      def read
+        relations_by_namespace = queries.relations.group_by{|row| row.fetch('namespace_name') }
+        namespaces = queries.namespaces.map do |namespace_row|
+          name = namespace_row.fetch('name')
+          relations = relations_by_namespace.fetch(name, []).map{|row| build_relation(name, row) }
+          Metadata::Namespace.new(name: name, relations: relations)
+        end
+        Metadata::Database.new(name: database_name, adapter: database_adapter, namespaces: namespaces)
+      end
+
+      private
+
+      attr_reader :queries
+
+      def database_name
+        queries.database.first&.fetch('name', nil) || 'mysql'
+      end
+
+      def database_adapter
+        connection.database_product.to_s.include?('MariaDB') ? :mariadb : :mysql
+      end
+
+      def build_relation(namespace, row)
+        relation = row.fetch('relation_name')
+        constraints = queries.constraints(namespace, relation)
+        Metadata::Relation.new(
+          name: relation,
+          kind: RELATION_KINDS.fetch(row.fetch('relation_kind')),
+          comment: present_comment(row['comment']),
+          columns: build_columns(queries.columns(namespace, relation)),
+          primary_key: build_primary_key(constraints),
+          foreign_keys: build_foreign_keys(constraints),
+          unique_constraints: build_unique_constraints(constraints),
+          check_constraints: build_checks(queries.checks(namespace, relation)),
+          indexes: build_indexes(queries.indexes(namespace, relation))
+        )
+      end
+
+      def build_columns(rows)
+        rows.map do |row|
+          generated = !row.fetch('generated_expression').to_s.empty?
+          Metadata::Column.new(
+            name: row.fetch('name'), logical_type: logical_type(row.fetch('logical_type'), row.fetch('sql_type')),
+            sql_type: row.fetch('sql_type'), nullable: row.fetch('nullable') == 'YES',
+            default: generated ? nil : row['default_expression'],
+            generated_expression: generated ? row.fetch('generated_expression') : nil,
+            identity: row.fetch('extra').to_s.include?('auto_increment') ? :by_default : nil,
+            ordinal: Integer(row.fetch('ordinal'))
+          )
+        end
+      end
+
+      def build_primary_key(rows)
+        group = constraint_groups(rows).find{|name, _items| name == 'PRIMARY' }
+        Metadata::PrimaryKey.new(name: group.first, columns: columns(group.last)) if group
+      end
+
+      def build_foreign_keys(rows)
+        constraint_groups(rows).filter_map do |name, items|
+          next unless items.first.fetch('constraint_type') == 'FOREIGN KEY'
+
+          Metadata::ForeignKey.new(
+            name: name, columns: columns(items), referenced_namespace: items.first.fetch('referenced_namespace'),
+            referenced_relation: items.first.fetch('referenced_relation'),
+            referenced_columns: items.map{|item| item.fetch('referenced_column') },
+            on_update: foreign_key_action(items.first['on_update']),
+            on_delete: foreign_key_action(items.first['on_delete'])
+          )
+        end
+      end
+
+      def build_unique_constraints(rows)
+        constraint_groups(rows).filter_map do |name, items|
+          next unless items.first.fetch('constraint_type') == 'UNIQUE'
+
+          Metadata::UniqueConstraint.new(name: name, columns: columns(items))
+        end
+      end
+
+      def build_checks(rows)
+        rows.map do |row|
+          Metadata::CheckConstraint.new(name: row.fetch('name'), expression: row.fetch('expression'))
+        end
+      end
+
+      def build_indexes(rows)
+        rows.group_by{|row| row.fetch('name') }.filter_map do |name, items|
+          index_columns = items.sort_by{|item| Integer(item.fetch('ordinal')) }.filter_map{|item| item['column_name'] }
+          next if index_columns.empty?
+
+          Metadata::Index.new(
+            name: name, columns: index_columns, unique: items.first.fetch('non_unique').to_i.zero?,
+            using: items.first.fetch('index_type').to_s.downcase
+          )
+        end
+      end
+
+      def constraint_groups(rows)
+        rows.group_by{|row| row.fetch('name') }
+      end
+
+      def columns(rows)
+        rows.sort_by{|row| Integer(row.fetch('ordinal')) }.map{|row| row.fetch('column_name') }
+      end
+
+      def logical_type(data_type, sql_type)
+        return :boolean if data_type == 'tinyint' && sql_type.match?(/tinyint\(1\)/i)
+
+        normalized = data_type.downcase
+        TYPE_MAPPINGS.find{|pattern, _type| normalized.match?(pattern) }&.last || normalized.to_sym
+      end
+
+      def foreign_key_action(value)
+        FOREIGN_KEY_ACTIONS.fetch(value.to_s.upcase, :no_action)
+      end
+
+      def present_comment(value)
+        value unless value.to_s.empty?
+      end
+    end
+  end
+end

data/lib/rdbr/catalog/postgresql/queries.rb

@@ -0,0 +1,171 @@
+module RDBr
+  module Catalog
+    class PostgresqlQueries
+      DATABASE_SQL = '/* rdbr: database */ SELECT current_database() AS name'.freeze
+      NAMESPACES_SQL = <<~SQL.freeze
+        /* rdbr: namespaces */
+        SELECT namespace.nspname AS name
+        FROM pg_namespace namespace
+        WHERE true
+          %<system_filter>s
+        ORDER BY namespace.nspname
+      SQL
+      RELATIONS_SQL = <<~SQL.freeze
+        /* rdbr: relations */
+        SELECT
+          relation.oid::bigint AS oid,
+          namespace.nspname AS namespace_name,
+          relation.relname AS relation_name,
+          relation.relkind AS relation_kind,
+          obj_description(relation.oid, 'pg_class') AS comment
+        FROM pg_class relation
+        INNER JOIN pg_namespace namespace ON namespace.oid = relation.relnamespace
+        WHERE relation.relkind IN ('r', 'p', 'v', 'm', 'f')
+          %<system_filter>s
+        ORDER BY namespace.nspname, relation.relname
+      SQL
+      COLUMNS_SQL = <<~SQL.freeze
+        /* rdbr: columns */
+        SELECT
+          attribute.attname AS name,
+          type.typname AS logical_type,
+          format_type(attribute.atttypid, attribute.atttypmod) AS sql_type,
+          NOT attribute.attnotnull AS nullable,
+          pg_get_expr(default_value.adbin, default_value.adrelid, true) AS default_expression,
+          %<generated_kind>s AS generated_kind,
+          attribute.attidentity AS identity_kind,
+          attribute.attnum AS ordinal
+        FROM pg_attribute attribute
+        INNER JOIN pg_type type ON type.oid = attribute.atttypid
+        LEFT JOIN pg_attrdef default_value
+          ON default_value.adrelid = attribute.attrelid
+         AND default_value.adnum = attribute.attnum
+        WHERE attribute.attrelid = %<relation_oid>d
+          AND attribute.attnum > 0
+          AND NOT attribute.attisdropped
+        ORDER BY attribute.attnum
+      SQL
+      CONSTRAINTS_SQL = <<~SQL.freeze
+        /* rdbr: constraints */
+        SELECT
+          constraint_record.conname AS name,
+          constraint_record.contype AS constraint_type,
+          to_json(ARRAY(
+            SELECT attribute.attname
+            FROM unnest(constraint_record.conkey) WITH ORDINALITY key(attribute_number, position)
+            INNER JOIN pg_attribute attribute
+              ON attribute.attrelid = constraint_record.conrelid
+             AND attribute.attnum = key.attribute_number
+            ORDER BY key.position
+          ))::text AS columns,
+          referenced_namespace.nspname AS referenced_namespace,
+          referenced_relation.relname AS referenced_relation,
+          to_json(ARRAY(
+            SELECT attribute.attname
+            FROM unnest(constraint_record.confkey) WITH ORDINALITY key(attribute_number, position)
+            INNER JOIN pg_attribute attribute
+              ON attribute.attrelid = constraint_record.confrelid
+             AND attribute.attnum = key.attribute_number
+            ORDER BY key.position
+          ))::text AS referenced_columns,
+          constraint_record.confupdtype AS on_update,
+          constraint_record.confdeltype AS on_delete,
+          pg_get_expr(constraint_record.conbin, constraint_record.conrelid, true) AS check_expression
+        FROM pg_constraint constraint_record
+        LEFT JOIN pg_class referenced_relation ON referenced_relation.oid = constraint_record.confrelid
+        LEFT JOIN pg_namespace referenced_namespace
+          ON referenced_namespace.oid = referenced_relation.relnamespace
+        WHERE constraint_record.conrelid = %<relation_oid>d
+          AND constraint_record.contype IN ('p', 'u', 'f', 'c')
+        ORDER BY constraint_record.conname
+      SQL
+      INDEXES_SQL = <<~SQL.freeze
+        /* rdbr: indexes */
+        SELECT
+          index_relation.relname AS name,
+          index.indisunique AS unique,
+          access_method.amname AS using,
+          pg_get_expr(index.indpred, index.indrelid, true) AS predicate,
+          json_agg(
+            json_build_object(
+              'column', attribute.attname,
+              'expression', CASE
+                WHEN key.attribute_number = 0
+                  THEN pg_get_indexdef(index.indexrelid, key.position::integer, true)
+              END
+            ) ORDER BY key.position
+          )::text AS parts
+        FROM pg_index index
+        INNER JOIN pg_class index_relation ON index_relation.oid = index.indexrelid
+        INNER JOIN pg_am access_method ON access_method.oid = index_relation.relam
+        CROSS JOIN LATERAL unnest(index.indkey)
+          WITH ORDINALITY key(attribute_number, position)
+        LEFT JOIN pg_attribute attribute
+          ON attribute.attrelid = index.indrelid
+         AND attribute.attnum = key.attribute_number
+        WHERE index.indrelid = %<relation_oid>d
+          AND key.position <= index.indnkeyatts
+        GROUP BY
+          index.indexrelid,
+          index_relation.relname,
+          index.indisunique,
+          access_method.amname,
+          index.indpred,
+          index.indrelid
+        ORDER BY index_relation.relname
+      SQL
+
+      def initialize(connection, include_system: false, generated_columns: true)
+        @connection = connection
+        @include_system = include_system
+        @generated_columns = generated_columns
+      end
+
+      def database
+        connection.select_all(DATABASE_SQL)
+      end
+
+      def namespaces
+        connection.select_all(format(NAMESPACES_SQL, system_filter: system_namespace_filter))
+      end
+
+      def relations
+        connection.select_all(format(RELATIONS_SQL, system_filter: system_namespace_filter))
+      end
+
+      def columns(relation_oid)
+        connection.select_all(
+          format(
+            COLUMNS_SQL,
+            relation_oid: Integer(relation_oid),
+            generated_kind: generated_kind_expression
+          )
+        )
+      end
+
+      def constraints(relation_oid)
+        connection.select_all(format(CONSTRAINTS_SQL, relation_oid: Integer(relation_oid)))
+      end
+
+      def indexes(relation_oid)
+        connection.select_all(format(INDEXES_SQL, relation_oid: Integer(relation_oid)))
+      end
+
+      private
+
+      attr_reader :connection
+
+      def generated_kind_expression
+        return 'attribute.attgenerated' if @generated_columns
+
+        "''::text"
+      end
+
+      def system_namespace_filter
+        return '' if @include_system
+
+        "AND namespace.nspname !~ '^pg_' AND namespace.nspname <> 'information_schema'"
+      end
+    end
+  end
+end

data/lib/rdbr/catalog/postgresql.rb

@@ -0,0 +1,138 @@
+require_relative 'postgresql/queries'
+
+module RDBr
+  module Catalog
+    class Postgresql < Reader
+      RELATION_KINDS = {
+        'r' => :table,
+        'p' => :partitioned_table,
+        'v' => :view,
+        'm' => :materialized_view,
+        'f' => :foreign_table
+      }.freeze
+      FOREIGN_KEY_ACTIONS = {
+        'a' => :no_action,
+        'r' => :restrict,
+        'c' => :cascade,
+        'n' => :set_null,
+        'd' => :set_default
+      }.freeze
+      IDENTITY_KINDS = { 'a' => :always, 'd' => :by_default }.freeze
+
+      def initialize(connection, include_system: false)
+        super
+        @queries = PostgresqlQueries.new(
+          connection,
+          include_system: include_system,
+          generated_columns: generated_columns_supported?(connection.database_version)
+        )
+      end
+
+      def read
+        relations_by_namespace = queries.relations.group_by{|row| row.fetch('namespace_name') }
+        namespaces = queries.namespaces.map do |namespace|
+          rows = relations_by_namespace.fetch(namespace.fetch('name'), [])
+          Metadata::Namespace.new(name: namespace.fetch('name'), relations: rows.map{|row| build_relation(row) })
+        end
+
+        Metadata::Database.new(name: database_name, adapter: :postgresql, namespaces: namespaces)
+      end
+
+      private
+
+      def generated_columns_supported?(version)
+        return version >= 120_000 if version.is_a?(Integer)
+
+        version >= Gem::Version.new('12')
+      end
+
+      attr_reader :queries
+
+      def database_name
+        queries.database.first.fetch('name')
+      end
+
+      def build_relation(row)
+        relation_oid = Integer(row.fetch('oid'))
+        constraints = queries.constraints(relation_oid)
+        Metadata::Relation.new(
+          name: row.fetch('relation_name'),
+          kind: RELATION_KINDS.fetch(row.fetch('relation_kind')),
+          comment: row['comment'],
+          columns: build_columns(relation_oid),
+          primary_key: build_primary_key(constraints),
+          foreign_keys: build_foreign_keys(constraints),
+          unique_constraints: build_unique_constraints(constraints),
+          check_constraints: build_check_constraints(constraints),
+          indexes: build_indexes(relation_oid)
+        )
+      end
+
+      def build_columns(relation_oid)
+        queries.columns(relation_oid).map do |row|
+          generated = row.fetch('generated_kind') != ''
+          expression = row['default_expression']
+          Metadata::Column.new(
+            name: row.fetch('name'),
+            logical_type: row.fetch('logical_type').to_sym,
+            sql_type: row.fetch('sql_type'),
+            nullable: row.fetch('nullable'),
+            default: generated ? nil : expression,
+            generated_expression: generated ? expression : nil,
+            identity: IDENTITY_KINDS[row.fetch('identity_kind')],
+            ordinal: Integer(row.fetch('ordinal'))
+          )
+        end
+      end
+
+      def build_primary_key(rows)
+        row = rows.find{|item| item.fetch('constraint_type') == 'p' }
+        Metadata::PrimaryKey.new(name: row.fetch('name'), columns: json_array(row.fetch('columns'))) if row
+      end
+
+      def build_foreign_keys(rows)
+        rows.select{|row| row.fetch('constraint_type') == 'f' }.map do |row|
+          Metadata::ForeignKey.new(
+            name: row.fetch('name'),
+            columns: json_array(row.fetch('columns')),
+            referenced_namespace: row.fetch('referenced_namespace'),
+            referenced_relation: row.fetch('referenced_relation'),
+            referenced_columns: json_array(row.fetch('referenced_columns')),
+            on_update: FOREIGN_KEY_ACTIONS.fetch(row.fetch('on_update')),
+            on_delete: FOREIGN_KEY_ACTIONS.fetch(row.fetch('on_delete'))
+          )
+        end
+      end
+
+      def build_unique_constraints(rows)
+        rows.select{|row| row.fetch('constraint_type') == 'u' }.map do |row|
+          Metadata::UniqueConstraint.new(name: row.fetch('name'), columns: json_array(row.fetch('columns')))
+        end
+      end
+
+      def build_check_constraints(rows)
+        rows.select{|row| row.fetch('constraint_type') == 'c' }.map do |row|
+          Metadata::CheckConstraint.new(name: row.fetch('name'), expression: row.fetch('check_expression'))
+        end
+      end
+
+      def build_indexes(relation_oid)
+        queries.indexes(relation_oid).map do |row|
+          parts = JSON.parse(row.fetch('parts'))
+          Metadata::Index.new(
+            name: row.fetch('name'),
+            columns: parts.filter_map{|part| part['column'] },
+            expressions: parts.filter_map{|part| part['expression'] },
+            unique: row.fetch('unique'),
+            where: row['predicate'],
+            using: row.fetch('using')
+          )
+        end
+      end
+
+      def json_array(value)
+        JSON.parse(value || '[]')
+      end
+    end
+  end
+end

data/lib/rdbr/catalog/reader.rb

@@ -0,0 +1,30 @@
+module RDBr
+  module Catalog
+    class Reader
+      def self.for(adapter_name)
+        return Postgresql if [ 'postgresql', 'postgis' ].include?(adapter_name)
+        return Sqlite if [ 'sqlite', 'sqlite3' ].include?(adapter_name)
+        return Mysql if [ 'mysql', 'mysql2', 'trilogy' ].include?(adapter_name)
+
+        raise UnsupportedAdapterError, "Unsupported database adapter: #{adapter_name}"
+      end
+
+      def initialize(connection, include_system: false)
+        @connection = connection
+        @include_system = include_system
+      end
+
+      def read
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :connection
+
+      def include_system?
+        @include_system
+      end
+    end
+  end
+end

data/lib/rdbr/catalog/serializer.rb

@@ -0,0 +1,24 @@
+module RDBr
+  module Catalog
+    module Serializer
+      module_function
+
+      def call(value)
+        case value
+        when Data
+          value.to_h.transform_values{|item| call(item) }
+        when Array
+          value.map{|item| call(item) }
+        when Hash
+          value.transform_values{|item| call(item) }
+        else
+          value
+        end
+      end
+
+      def pretty_json(value)
+        JSON.pretty_generate(call(value))
+      end
+    end
+  end
+end