rdbr 0.1.0

data/lib/rdbr/web/relationship_loader.rb

@@ -0,0 +1,65 @@
+module RDBr
+  module Web
+    module RelationshipLoader
+      include ThroughRelationshipLoader
+
+      private
+
+      def outgoing_relationships
+        settings.catalog.outgoing_relationships(@namespace, @relation).filter_map do |relationship|
+          outgoing_relationship(relationship)
+        end
+      end
+
+      def outgoing_relationship(relationship)
+        foreign_key = relationship.foreign_key
+        namespace = relationship.target_namespace
+        relation = relationship.target_relation
+
+        key = foreign_key.referenced_columns.zip(foreign_key.columns.map{|column| @record[column] }).to_h
+        return if key.values.any?(&:nil?)
+
+        { foreign_key: foreign_key, namespace: namespace, relation: relation, inferred: relationship.inferred,
+          url: relationship_url(namespace, relation, key) }
+      end
+
+      def incoming_relationships
+        settings.catalog.incoming_relationships(@namespace, @relation).filter_map do |relationship|
+          next if through_junction?(relationship)
+
+          foreign_key = relationship.foreign_key
+          values = foreign_key.referenced_columns.map{|column| @record[column] }
+          next if values.any?(&:nil?)
+
+          related_page(relationship, foreign_key.columns.zip(values).to_h)
+        end
+      end
+
+      def related_page(relationship, filters)
+        namespace = relationship.source_namespace
+        relation = relationship.source_relation
+        page = settings.query_service.page(
+          namespace: namespace.name, relation: relation.name, filters: filters, per_page: 10
+        )
+        return if page.rows.empty?
+
+        { foreign_key: relationship.foreign_key, namespace: namespace, relation: relation,
+          inferred: relationship.inferred,
+          page: page, url: relation_url(namespace.name, relation.name, filter: equality_filters(filters)) }
+      end
+
+      def relationship_url(namespace, relation, key)
+        primary_key = relation.primary_key
+        if primary_key&.columns&.sort == key.keys.sort
+          return record_url(namespace.name, relation.name, key, primary_key)
+        end
+
+        relation_url(namespace.name, relation.name, filter: equality_filters(key))
+      end
+
+      def equality_filters(values)
+        values.transform_values{|value| { eq: value } }
+      end
+    end
+  end
+end

data/lib/rdbr/web/search_value_helpers.rb

@@ -0,0 +1,58 @@
+module RDBr
+  module Web
+    module SearchValueHelpers
+      BIT_TYPES = %i[bit varbit].freeze
+      SEARCH_TYPES = %i[tsquery tsvector].freeze
+
+      def deferred_bit_value?(column)
+        type = column.logical_type.to_s.to_sym
+        (BIT_TYPES.include?(type) || column.sql_type.to_s.match?(/\bbit(?: varying)?\b/i)) && !vector_column?(column)
+      end
+
+      def deferred_search_value?(column)
+        type = column.logical_type.to_s.to_sym
+        SEARCH_TYPES.include?(type) || column.sql_type.to_s.match?(/\b(?:tsquery|tsvector)\b/i)
+      end
+
+      def render_bit_value(value)
+        text = value.to_s
+        length = bit_content(text).length
+        unit = length == 1 ? 'bit' : 'bits'
+        render_deferred_value(text, qualifier: 'bit-string', summary: "#{length} #{unit}")
+      end
+
+      def render_search_value(column, value)
+        type = search_type(column)
+        summary = type == :tsvector ? tsvector_summary(value) : tsquery_summary(value)
+        render_deferred_value(value, qualifier: 'full-text', summary: summary)
+      end
+
+      private
+
+      def bit_content(text)
+        match = text.strip.match(/\A(?:B)?'([01]*)'\z/i)
+        match ? match[1] : text
+      end
+
+      def search_type(column)
+        type = column.logical_type.to_s.to_sym
+        return type if SEARCH_TYPES.include?(type)
+
+        column.sql_type.to_s.match?(/\btsvector\b/i) ? :tsvector : :tsquery
+      end
+
+      def tsvector_summary(value)
+        count = value.to_s.scan(/'(?:[^']|'')+'/).length
+        unit = count == 1 ? 'lexeme' : 'lexemes'
+        "#{count} #{unit}"
+      end
+
+      def tsquery_summary(value)
+        count = value.to_s.scan(/'(?:[^']|'')+'/).length
+        count = value.to_s.scan(/[[:alnum:]_]+/).length if count.zero?
+        unit = count == 1 ? 'term' : 'terms'
+        "Full-text query · #{count} #{unit}"
+      end
+    end
+  end
+end

data/lib/rdbr/web/spatial_value_helpers.rb

@@ -0,0 +1,83 @@
+require 'base64'
+
+module RDBr
+  module Web
+    module SpatialValueHelpers
+      SPATIAL_TYPES = %i[box circle geography geometry line lseg path point polygon].freeze
+      GEOMETRY_NAMES = {
+        'geometrycollection' => 'Geometry collection', 'linestring' => 'Line string',
+        'multilinestring' => 'Multi-line string', 'multipoint' => 'Multi-point',
+        'multipolygon' => 'Multi-polygon', 'point' => 'Point', 'polygon' => 'Polygon'
+      }.freeze
+
+      def spatial_column?(column)
+        type = column.logical_type.to_s.downcase.to_sym
+        SPATIAL_TYPES.include?(type) || column.sql_type.to_s.match?(spatial_type_pattern)
+      end
+
+      def render_spatial_value(column, value)
+        text, summary = spatial_presentation(column, value)
+        render_deferred_value(text, qualifier: 'spatial', summary: summary)
+      end
+
+      private
+
+      def spatial_type_pattern
+        /\A(?:box|circle|geography|geometry|line|lseg|path|point|polygon)\b/i
+      end
+
+      def spatial_presentation(column, value)
+        return encoded_spatial_presentation(value) if encoded_spatial_value?(value)
+        return geo_json_presentation(value) if value.is_a?(Hash)
+        return raw_binary_spatial_presentation(value) if raw_binary_spatial_value?(value)
+
+        spatial_text_presentation(column, value.to_s)
+      end
+
+      def encoded_spatial_value?(value)
+        value.is_a?(Hash) && value['encoding'] == 'base64' && value.key?('data')
+      end
+
+      def encoded_spatial_presentation(value)
+        payload = value.fetch('data').to_s
+        bytes = Base64.strict_decode64(payload).bytesize
+        [ payload, "Geometry · #{bytes} bytes · Base64" ]
+      rescue ArgumentError
+        [ payload, 'Geometry · Base64' ]
+      end
+
+      def geo_json_presentation(value)
+        kind = geometry_name(value['type'] || value[:type]) || 'Geometry'
+        [ JSON.pretty_generate(value), "#{kind} · GeoJSON" ]
+      end
+
+      def raw_binary_spatial_value?(value)
+        value.is_a?(String) && value.encoding == Encoding::BINARY
+      end
+
+      def raw_binary_spatial_presentation(value)
+        [ Base64.strict_encode64(value), "Geometry · #{value.bytesize} bytes · Base64" ]
+      end
+
+      def spatial_text_presentation(column, text)
+        srid = text.match(/\ASRID=(\d+);/i)&.[](1)
+        body = text.sub(/\ASRID=\d+;/i, '')
+        kind = geometry_name(body[/\A([[:alpha:]]+)/, 1]) || geometry_name(column.logical_type) || 'Geometry'
+        suffix = srid ? " · SRID #{srid}" : spatial_encoding_suffix(body)
+        [ text, "#{kind}#{suffix}" ]
+      end
+
+      def geometry_name(value)
+        text = value.to_s
+        GEOMETRY_NAMES[text.downcase] || (text.capitalize unless text.empty?)
+      end
+
+      def spatial_encoding_suffix(text)
+        hex = text.delete_prefix('\\x')
+        return '' unless hex.match?(/\A[[:xdigit:]]+\z/) && hex.length.even?
+
+        " · #{hex.length / 2} bytes · hex"
+      end
+    end
+  end
+end

data/lib/rdbr/web/through_relationship_loader.rb

@@ -0,0 +1,90 @@
+module RDBr
+  module Web
+    module ThroughRelationshipLoader
+      private
+
+      def through_relationships
+        settings.catalog.through_relationships(@namespace, @relation).filter_map do |relationship|
+          through_relationship(relationship)
+        end
+      end
+
+      def through_relationship(relationship)
+        source_key = relationship.source_foreign_key
+        values = source_key.referenced_columns.map{|column| @record[column] }
+        return if values.any?(&:nil?)
+
+        filters = source_key.columns.zip(values).to_h
+        junction_page = settings.query_service.page(
+          namespace: relationship.junction_namespace.name, relation: relationship.junction_relation.name,
+          filters: filters, per_page: 10
+        )
+
+        { relationship: relationship, junction_page: junction_page,
+          junction_url: relation_url(relationship.junction_namespace.name, relationship.junction_relation.name,
+                                     filter: equality_filters(filters)),
+          targets: through_targets(relationship, junction_page.rows) }
+      end
+
+      def through_junction?(direct_relationship)
+        @through_relationships.any? do |entry|
+          through = entry.fetch(:relationship)
+          through.junction_namespace == direct_relationship.source_namespace &&
+            through.junction_relation == direct_relationship.source_relation
+        end
+      end
+
+      def through_targets(relationship, rows)
+        foreign_key = relationship.target_foreign_key
+        keyed_rows = through_target_keys(foreign_key, rows)
+        targets = lookup_through_targets(relationship, keyed_rows)
+        targets_by_key = index_through_targets(foreign_key, targets)
+
+        keyed_rows.map do |junction_row, values|
+          build_through_target(relationship, junction_row, values, targets_by_key[values.values])
+        end
+      end
+
+      def through_target_keys(foreign_key, rows)
+        rows.filter_map do |row|
+          values = foreign_key.referenced_columns.zip(
+            foreign_key.columns.map{|column| row[column] }
+          ).to_h
+          [ row, values ] unless values.values.any?(&:nil?)
+        end
+      end
+
+      def lookup_through_targets(relationship, keyed_rows)
+        settings.query_service.lookup(
+          namespace: relationship.target_namespace.name, relation: relationship.target_relation.name,
+          keys: keyed_rows.map(&:last)
+        )
+      end
+
+      def index_through_targets(foreign_key, targets)
+        targets.index_by do |target|
+          foreign_key.referenced_columns.map{|column| target[column] }
+        end
+      end
+
+      def build_through_target(relationship, junction_row, values, target)
+        {
+          row: target,
+          url: target && relationship_url(relationship.target_namespace, relationship.target_relation, values),
+          junction_url: junction_record_url(relationship, junction_row)
+        }
+      end
+
+      def junction_record_url(relationship, row)
+        namespace = relationship.junction_namespace
+        relation = relationship.junction_relation
+        primary_key = relation.primary_key
+        return record_url(namespace.name, relation.name, row, primary_key) if primary_key
+
+        columns = relationship.source_foreign_key.columns | relationship.target_foreign_key.columns
+        values = columns.to_h{|column| [ column, row[column]] }
+        relation_url(namespace.name, relation.name, filter: equality_filters(values))
+      end
+    end
+  end
+end

data/lib/rdbr/web/vector_value_helpers.rb

@@ -0,0 +1,59 @@
+module RDBr
+  module Web
+    module VectorValueHelpers
+      VECTOR_TYPES = %w[vector halfvec sparsevec].freeze
+      BIT_TYPES = %w[bit varbit].freeze
+      VECTOR_NAMES = %w[embedding embeddings vector vectors].freeze
+
+      def vector_column?(column)
+        type = column.logical_type.to_s.downcase
+        sql_type = column.sql_type.to_s.downcase
+        VECTOR_TYPES.include?(type) || sql_type.match?(/\b(?:vector|halfvec|sparsevec)\b/) ||
+          binary_vector_column?(column, type)
+      end
+
+      def render_vector_value(column, value)
+        render_deferred_value(
+          vector_text(value), qualifier: 'vector', summary: vector_summary(column, value)
+        )
+      end
+
+      private
+
+      def binary_vector_column?(column, type)
+        return false unless BIT_TYPES.include?(type)
+
+        name_parts = column.name.gsub(/([a-z\d])([A-Z])/, '\\1_\\2').downcase.split(/[^a-z0-9]+/)
+        (name_parts & VECTOR_NAMES).any?
+      end
+
+      def vector_summary(column, value)
+        dimensions = vector_dimensions(column, value)
+        return 'Vector' unless dimensions
+
+        "#{dimensions}-dimensional vector"
+      end
+
+      def vector_dimensions(column, value)
+        declared = column.sql_type.to_s.match(/\b(?:vector|halfvec|bit|varbit)\s*\(\s*(\d+)\s*\)/i)
+        return Integer(declared[1]) if declared
+        return value.length if value.is_a?(Array)
+
+        text = value.to_s.strip
+        sparse_dimensions = text.match(%r{/\s*(\d+)\s*\z})
+        return Integer(sparse_dimensions[1]) if sparse_dimensions
+        if BIT_TYPES.include?(column.logical_type.to_s.downcase)
+          return text.delete_prefix("B'").delete_suffix("'").length
+        end
+        return unless text.start_with?('[') && text.end_with?(']')
+
+        body = text[1...-1].strip
+        body.empty? ? 0 : body.count(',') + 1
+      end
+
+      def vector_text(value)
+        value.is_a?(Array) ? JSON.generate(value) : value.to_s
+      end
+    end
+  end
+end

data/lib/rdbr.rb

@@ -0,0 +1,25 @@
+require 'active_record'
+require 'haml'
+require 'json'
+require 'sinatra/base'
+require 'time'
+
+require_relative 'rdbr/version'
+require_relative 'rdbr/metadata'
+require_relative 'rdbr/catalog'
+require_relative 'rdbr/access'
+require_relative 'rdbr/query'
+require_relative 'rdbr/presentation/record_identity'
+require_relative 'rdbr/browser_launcher'
+require_relative 'rdbr/cli_options'
+require_relative 'rdbr/cli'
+require_relative 'rdbr/web/helpers'
+require_relative 'rdbr/web/column_preferences'
+require_relative 'rdbr/web/json_page_stream'
+require_relative 'rdbr/web/through_relationship_loader'
+require_relative 'rdbr/web/relationship_loader'
+require_relative 'rdbr/web/database_graph'
+require_relative 'rdbr/web/application'
+
+module RDBr
+end

metadata

@@ -0,0 +1,298 @@
+--- !ruby/object:Gem::Specification
+name: rdbr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Blake
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RDBr discovers relational database structure and presents a generic,
+  read-only web interface.
+email:
+- blakethomasandrew@gmail.com
+executables:
+- rdbr
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- app/public/application.js
+- app/public/database-diagram.js
+- app/public/styles.css
+- app/views/data.haml
+- app/views/group.haml
+- app/views/index.haml
+- app/views/layout.haml
+- app/views/record.haml
+- demo/README.md
+- demo/compose.yml
+- demo/seed.rb
+- demo/smoke.rb
+- docs/RELEASING.md
+- docs/VALUE_PRESENTATION.md
+- exe/rdbr
+- lib/rdbr.rb
+- lib/rdbr/access.rb
+- lib/rdbr/access/read_only.rb
+- lib/rdbr/browser_launcher.rb
+- lib/rdbr/catalog.rb
+- lib/rdbr/catalog/connection.rb
+- lib/rdbr/catalog/errors.rb
+- lib/rdbr/catalog/mysql.rb
+- lib/rdbr/catalog/mysql/queries.rb
+- lib/rdbr/catalog/postgresql.rb
+- lib/rdbr/catalog/postgresql/queries.rb
+- lib/rdbr/catalog/reader.rb
+- lib/rdbr/catalog/serializer.rb
+- lib/rdbr/catalog/sqlite.rb
+- lib/rdbr/cli.rb
+- lib/rdbr/cli_options.rb
+- lib/rdbr/metadata.rb
+- lib/rdbr/metadata/column.rb
+- lib/rdbr/metadata/constraints.rb
+- lib/rdbr/metadata/database.rb
+- lib/rdbr/metadata/index.rb
+- lib/rdbr/metadata/keys.rb
+- lib/rdbr/metadata/namespace.rb
+- lib/rdbr/metadata/relation.rb
+- lib/rdbr/metadata/relationship_inference.rb
+- lib/rdbr/metadata/relationships.rb
+- lib/rdbr/metadata/values.rb
+- lib/rdbr/presentation/record_identity.rb
+- lib/rdbr/query.rb
+- lib/rdbr/query/connection.rb
+- lib/rdbr/query/errors.rb
+- lib/rdbr/query/lookup.rb
+- lib/rdbr/query/mysql.rb
+- lib/rdbr/query/page.rb
+- lib/rdbr/query/postgresql.rb
+- lib/rdbr/query/postgresql_dialect.rb
+- lib/rdbr/query/relational.rb
+- lib/rdbr/query/sqlite.rb
+- lib/rdbr/query/type_support.rb
+- lib/rdbr/query/value_limiter.rb
+- lib/rdbr/version.rb
+- lib/rdbr/web/application.rb
+- lib/rdbr/web/array_value_helpers.rb
+- lib/rdbr/web/binary_value_helpers.rb
+- lib/rdbr/web/column_preferences.rb
+- lib/rdbr/web/database_graph.rb
+- lib/rdbr/web/deferred_column_value_helpers.rb
+- lib/rdbr/web/deferred_value_helpers.rb
+- lib/rdbr/web/document_value_helpers.rb
+- lib/rdbr/web/filter_presentation_helpers.rb
+- lib/rdbr/web/helpers.rb
+- lib/rdbr/web/identifier_value_helpers.rb
+- lib/rdbr/web/json_page_stream.rb
+- lib/rdbr/web/navigation_helpers.rb
+- lib/rdbr/web/presentation_helpers.rb
+- lib/rdbr/web/range_value_helpers.rb
+- lib/rdbr/web/record_value_helpers.rb
+- lib/rdbr/web/related_value_helpers.rb
+- lib/rdbr/web/relationship_loader.rb
+- lib/rdbr/web/search_value_helpers.rb
+- lib/rdbr/web/spatial_value_helpers.rb
+- lib/rdbr/web/through_relationship_loader.rb
+- lib/rdbr/web/vector_value_helpers.rb
+homepage: https://github.com/andrewtblake/rdbr
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/andrewtblake/rdbr
+  changelog_uri: https://github.com/andrewtblake/rdbr/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/andrewtblake/rdbr#readme
+  bug_tracker_uri: https://github.com/andrewtblake/rdbr/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: A standalone, read-only browser for relational databases
+test_files: []