pg_graph 0.1.0

data/lib/type/type.rb

@@ -0,0 +1,617 @@
+
+module PgGraph::Type
+  class Error < StandardError; end
+  
+  class Node < HashTree::Set
+    include Constrain
+
+    alias_method :uid, :path
+    def guid() root.name + "." + uid end
+
+    alias_method :name, :key
+
+    # The Ruby model identifier of the object. It corresponds to #name
+    def identifier() PgGraph.inflector.camelize(name) end
+
+    # The full Ruby model identifier of the object within a database. It
+    # corresponds to #uid
+    def schema_identifier() identifier end
+    
+    # :call-seq: initialize(database, name, attach: true)
+    def initialize(parent, name, **opts)
+      constrain parent, Node, NilClass
+      constrain name, String, NilClass
+      super
+    end
+
+    def inspect(payload = inspect_inner) 
+      "#<#{self.class}:#{name.inspect}#{payload ? " #{payload}" : ""}>" 
+    end
+
+    def inspect_inner() nil end
+
+  protected
+    # Nodes with nil keys are not attached. This is used in PgCatalogSchema to
+    # avoid being included in the list of schemas
+    def do_attach(key, child) super if child end
+
+    # Forward list of methods to object. The arguments should be strings or symbols
+    def self.forward_method(object, *methods)
+      for method in Array(methods).flatten
+        class_eval("def #{method}(*args) #{object}.#{method}(*args) end")
+      end
+    end
+  end
+
+  # Included by tables, records, and fields
+  module TableObject
+    # Circular definitions. Classes that include TableObject should redefine at least 
+    # one of the methods to break the loop
+    def table() record_type.table end
+    def table_type() table.type end
+    def record_type() table_type.record_type end
+  end
+
+  # Database is the top-level object and #read is the starting point for
+  # loading the type system in PgGraph::Type.new
+  class Database < Node
+    def guid() name end
+
+    alias_method :schemas, :values
+    attr_reader :catalog
+
+    # List of all tables in the database
+    def tables() schemas.map(&:tables).flatten end
+
+    # The reflector object. The reflector object takes a name of a link field
+    # and produce the field name in this table and the corrsponding field name
+    # in the other table
+    attr_reader :reflector
+
+    def initialize(name, reflector = PgGraph::Reflector.new)
+      constrain name, String
+      constrain reflector, PgGraph::Reflector
+      super(nil, name)
+      @catalog = PgCatalogSchema.new(self)
+      @reflector = reflector
+    end
+
+    def dot_lookup(key)
+      super || catalog[key]
+    end
+
+    # TODO
+    # def to_yaml() end
+    # def self.load_yaml() end
+
+    # Make Database pretend it is a PgGraph::Type object
+    def is_a?(klass) klass == PgGraph::Type || super end
+
+    def read(arg, reflector = nil, ignore: [])
+      constrain arg, PgMeta, PgConn
+      @reflector = reflector || @reflector
+      case arg
+        # #read_meta is a member of Database but defined in read.rb
+        when PgMeta; read_meta(arg, ignore: ignore) 
+        when PgConn; read_meta(PgMeta.new(arg), ignore: ignore)
+      end
+    end
+  end
+
+  class Schema < Node
+    alias_method :database, :parent
+    alias_method :objects, :values
+
+    def tables() objects.select { |child| child.is_a?(Table) } end
+    def types() objects.select { |child| child.is_a?(Type) } end
+    def record_types() objects.select { |child| child.is_a?(RecordType) } end
+
+    # :call-seq: initialize(database, name, attach: true)
+    #
+    # +attach:false+ is used when initializing the pg_catalog schema object
+    def initialize(database, name, **opts)
+      constrain database, Database
+      super(database, name, **opts)
+    end
+  end
+
+  class PgCatalogSchema < Schema
+    def schema_identifier() nil end
+    def initialize(database) super(database, "pg_catalog", attach: false) end
+  end
+
+  # Schema objects are owned by the schema. This includes tables and
+  # user-defined types but not records that are owned by their tables
+  class SchemaObject < Node
+    alias_method :schema, :parent
+
+    def initialize(schema, name)
+      constrain schema, Schema
+      super
+    end
+
+    def schema_identifier
+      [schema.schema_identifier, identifier].compact.join("::")
+    end
+  end
+
+  # A table. Note that a table doesn't have child objects. Instead it has a type
+  # property that has the record type as child
+  class Table < SchemaObject
+    include TableObject
+
+    # Qualified name of table (ie. schema.table). FIXME: We already have Node#path???
+    attr_reader :path
+
+    # Table type. Initially nil. Initialized by RecordType.new
+    attr_reader :type
+    alias_method :table_type, :type # Required TableObject method
+
+    forward_method :type, :keys, :fields, :key?, :[], :columns, :value_columns, :column?
+
+    # Parent table if table is a derived table and otherwise nil. Initialized by #read
+    attr_reader :supertable
+
+    # True if table is a parent table. Initialized by #read
+    def supertable?() @has_subtables || false end
+
+    # True if table is a derived table
+    def subtable?() !@supertable.nil? end
+
+    def mm_table?() @mm_table end
+    def nm_table?() @nm_table end
+
+    # Array of tables in the transitive closure of table dependencies. It is
+    # initialized by Database#read_meta
+    attr_reader :depending_tables
+
+    # This is a hack since graph_db doesn't model views. It is needed because
+    # PgGraph::Data needs to know which materialized views to refresh after
+    # data has been loaded
+    attr_reader :depending_materialized_views
+
+    def initialize(
+        schema, name,
+        mm_table: false, nm_table: false, depending_materialized_views: [])
+      PgGraph.inflector.plural?(name) or raise Error, "Table names should be plural: #{name.inspect}"
+      super(schema, name)
+      @path = "#{schema.name}.#{name}"
+      @mm_table = mm_table || nm_table
+      @nm_table = nm_table
+      @depending_tables = []
+      @depending_materialized_views = depending_materialized_views
+    end
+
+  protected
+    def type=(t) @type = t end
+  end
+
+  # A type
+  class Type < SchemaObject
+    def rank() raise Error, "Abstract method" end
+    def array?() false end
+    def tuple?() false end
+    def value?() false end
+
+    def initialize(schema, name)
+      super(schema, name)
+    end
+
+    # Return array type of self. Schema defaults to the schema of self
+    def array_type(schema = self.schema)
+      array_name = PgGraph.inflector.type2array(name)
+      @array_type ||= schema[array_name] || ArrayType.new(schema, nil, self)
+    end
+  end
+
+  # TODO: Rename to CatalogType or PgType or PostgresType
+  class SimpleType < Type
+    alias_method :postgres_type, :key
+    attr_reader :ruby_class
+    def identifier() ruby_class.to_s end
+
+    def rank() 0 end
+    def value?() true end
+
+    def initialize(schema, postgres_type)
+      super(schema, postgres_type)
+      @ruby_class = PgGraph.inflector.postgres_type2ruby_class(postgres_type)
+    end
+  end
+
+  class CompositeType < Type
+    alias_method :fields, :values
+    def rank() 1 end
+    def tuple?() true end
+  end
+
+  class RecordType < CompositeType
+    include TableObject
+
+    # List of postgres columns. The columns are sorted by ordinal
+    def columns() 
+      @columns ||= begin
+        cols = fields.map { |field|
+          case field
+            when SimpleColumn; field
+            when KindRecordColumn; 
+              if field.kind_column&.parent
+                nil
+              else
+                field.kind_column
+              end
+          else
+            nil
+          end
+        }.compact.sort_by(&:ordinal)
+#       @columns_hash = @columns.map { |column| [column.name, column] }.to_h
+        cols
+      end
+    end
+
+    def postgres_columns()
+      @postgres_columns ||= begin
+        cols = fields.map { |field|
+          case field
+            when SimpleColumn; field
+            when KindRecordColumn; 
+              if field.kind_column&.parent
+                nil
+              else
+                field.kind_column
+              end
+          else
+            nil
+          end
+        }.compact.sort_by(&:ordinal)
+#       @columns_ hash = @columns.map { |column| [column.name, column] }.to_h
+        cols
+      end
+    end
+
+    # TODO: Rename #columns to #postgres_columns and #abstract_columns to #columns
+    def abstract_columns 
+      @abstract_columns ||= fields.map { |field|
+          case field
+            when SimpleColumn; field
+            when KindRecordColumn;
+              field.kind_column if field.kind_column.parent.nil?
+          else
+            nil
+          end
+        }.compact.sort_by(&:ordinal)
+        
+    end
+
+#       field.is_a?(SimpleColumn) || field.is_a?(KindReference}.sort_by(&:ordinal) end
+
+    # List of columns excluding generated fields
+    def value_columns() 
+      columns.select { |column| !column.generated? }
+    end
+
+    # True iff name if the name of a postgres column
+#   def column?(name) self[name].is_a?(SimpleColumn) end
+    def column?(name) 
+      raise "See the rename TODO above"
+      @columns_hash.key?(name) 
+    end
+
+    # Associated Table object
+    attr_reader :table
+
+    # Redefine array_type
+    def array_type() table_type end
+
+    # A record type has the schema as parent. Note that a record is
+    # initialized with a Table object and not a TableType object
+    def initialize(table)
+      constrain table, Table
+      super(table.schema, PgGraph.inflector.table2record_type(table.name))
+      @table = table
+      table_type = TableType.new(table.schema, self) # FIXME
+      @table.send(:type=, table_type)
+    end
+
+    def attach(*args)
+      @columns = nil
+      super
+    end
+  end
+
+  class ArrayType < Type
+    DEFAULT_MAX_DIMENSIONS = 5
+
+    attr_reader :element_type
+    attr_reader :dimensions
+
+    def rank() 2 end
+    def array?() true end
+
+    def initialize(schema, name, element_type, dimensions = 1)
+      constrain element_type, Type
+      self.class < TableObject or !element_type.is_a?(TableObject) or raise "Illegal element type"
+      dimensions <= ArrayType.max_dimensions or raise Error, "Array dimension overflow"
+      super(schema, name || PgGraph.inflector.type2array(element_type.name))
+      @element_type = element_type
+      @dimensions = dimensions
+    end
+
+    def identifier
+      "[#{element_type.identifier}]"
+    end
+
+    def schema_identifier
+      "[#{element_type.schema_identifier}]"
+    end
+
+  private
+    @max_dimensions = DEFAULT_MAX_DIMENSIONS
+    def self.max_dimensions() @max_dimensions end
+    def self.max_dimensions=(max) @max_dimensions = max end
+  end
+
+  # Note that the name of a TableType object is the record name in brackets
+  # while the name of a Table object is the pluralized record name
+  class TableType < ArrayType
+    include TableObject
+
+    alias_method :record_type, :element_type
+    forward_method :record_type, :keys, :fields, :key?, :[], :columns, :value_columns, :column?
+
+    def array_type() raise Error, "Array of TableType is not allowed" end
+
+    def initialize(schema, record_type)
+      constrain record_type, RecordType
+      super(schema, nil, record_type)
+    end
+
+    def identifier
+      "{#{element_type.identifier}}"
+    end
+
+    def schema_identifier
+      "{#{element_type.schema_identifier}}"
+    end
+  end
+
+  class Field < Node
+    alias_method :composite_type, :parent
+    forward_method :type, :rank
+    attr_reader :type
+
+    def initialize(composite_type, name, type)
+      constrain composite_type, CompositeType, NilClass
+      self.class < TableObject or !type.is_a?(TableObject) or raise "Illegal field type"
+      super(composite_type, name)
+      @type = type
+    end
+
+    def identifier() name end
+
+    def schema_identifier
+      composite_type.schema_identifier + '.' + identifier
+    end
+  end
+
+  # A field in a RecordType
+  class Column < Field
+    include TableObject
+
+    alias_method :record_type, :parent
+
+    # nil for TableColumn and SubRecordColumn objects
+    attr_reader :postgres_column
+
+    # Return true/false or nil if postgres_column is nil
+    def primary_key?() @postgres_column && @primary_key end
+
+    # Return true/false or nil if postgres_column is an identity column.
+    # Sub-keys are primary keys but not identity keys 
+    def identity?() @postgres_column && @identity end
+
+    # Return true/false or nil
+    def nullable?() @postgres_column && @nullable end
+
+    # Return true/false or nil
+    def unique?() @postgres_column && @unique end
+
+    # Return true/false or nil
+    def readonly?() @postgres_column && @readonly end
+
+    # Return true/false or nil
+    def generated?() @postgres_column && @generated end
+
+    # True if column is a reference
+    def reference?() @postgres_column && @reference end
+
+    # True if column is a kind reference
+    def kind?() @postgres_column && @kind end
+
+  protected
+    def initialize(
+        record_type, name, postgres_column, type, 
+        primary_key: false, identity: false, 
+        reference: false, kind: false,
+        nullable: true, unique: false, readonly: false, generated: false)
+      constrain record_type, RecordType, NilClass
+      constrain type, Type
+      super(record_type, name, type)
+      @postgres_column = postgres_column
+      @primary_key = primary_key
+      @identity = identity
+      @reference = reference
+      @kind = kind
+      @nullable = nullable
+      @unique = unique
+      @readonly = readonly
+      @generated = generated
+    end
+  end
+
+  # Note that this includes array columns (for now)
+  class SimpleColumn < Column
+    # Ordinal of column in the database
+    attr_reader :ordinal
+
+    forward_method :type, :postgres_type, :ruby_class
+
+    def initialize(record_type, name, postgres_column, type, **opts)
+      constrain type, Type
+      !type.is_a?(TableObject) or raise "Illegal field type: #{type.class}"
+      @ordinal = opts.delete(:ordinal)
+      super
+    end
+
+    # Return true if the ruby literal match the column type
+    def literal?(text) text.is_a?(ruby_class) end
+  end
+
+  class RecordColumn < Column
+    # Postgres column in the embedding record that links to the referenced
+    # record
+    attr_reader :this_link_column
+
+    # Postgres column in the referenced record that links to the embedding
+    # record
+    attr_reader :that_link_column
+
+    # TODO: Is postgres_column == this_link_column?
+    def initialize(record_type, name, postgres_column, type, this_link_column, that_link_column, **opts)
+      constrain type, RecordType, NilClass
+      super(record_type, name, postgres_column, type, reference: true, **opts)
+      @this_link_column = this_link_column
+      @that_link_column = that_link_column
+    end
+
+    forward_method :type, :keys, :fields, :key?, :[], :columns, :column?
+
+    # Redefine #dot_lookup to make #dot enter the target record
+    def dot_lookup(key) type[key] end
+  end
+
+  class KindRecordColumn < RecordColumn
+    # A SimpleColumn object. Note that it doesn't have a parent to avoid having
+    # two columns with the same name: This structured KindRecordColumn object
+    # and the underlying kind column
+    attr_reader :kind_column
+
+    forward_method :kind_column, :literal?
+
+    def initialize(
+        record_type, name, postgres_column, type, 
+        this_link_column, that_link_column, 
+        kind_column, **opts)
+      constrain kind_column, SimpleColumn
+      super(record_type, name, postgres_column, type, this_link_column, that_link_column, kind: true, **opts)
+      @kind_column = kind_column
+    end
+  end
+
+  # A record in a 1:1 relationship with another record linked by identical IDs.
+  # SuperRecordColumn is on the "child" side of the relation because a child
+  # has a super record - hence the name
+  class SuperRecordColumn < RecordColumn
+    def initialize(record_type, name = nil, type)
+      name ||= type.name
+      super(
+          record_type, name, "id", type, "id", "id",
+          primary_key: true, nullable: false, unique: true, readonly: true)
+    end
+  end
+
+  # SubRecordColumn is on the "parent" side of the relation because a a parent
+  # has a sub record - hence the name
+  class SubRecordColumn < RecordColumn
+    def initialize(record_type, name = nil, type)
+      name ||= type.name
+      super(
+          record_type, name, "id", type, "id", "id",
+          primary_key: nil, nullable: nil, unique: nil, readonly: nil)
+    end
+  end
+
+  class TableColumn < Column
+    # Postgres column in the embedding record that links (directly or
+    # indirectly) to the subject table. This is typically the id column
+    attr_reader :this_link_column
+
+    # Postgres column in the subject table that directly or indirectly links to
+    # the embedding record. This is typically the '<this-table>_id' column of
+    # that table in 1:N relations
+    attr_reader :that_link_column
+
+    forward_method :type, :keys, :fields, :key?, :[], :columns, :column?
+
+    def initialize(record_type, name, type, this_link_column, that_link_column, **opts)
+      constrain record_type, RecordType
+      constrain type, TableType
+      super(record_type, name, nil, type, **opts)
+      @this_link_column = this_link_column
+      @that_link_column = that_link_column
+    end
+
+    def dot_lookup(key) type[key] end
+  end
+
+  class MmTableColumn < TableColumn
+    # This table in the relationship
+    alias_method :this_table, :table
+    alias_method :this_table_type, :table_type
+    alias_method :this_record_type, :record_type
+
+    # The other table in the relationship
+    def that_table() that_table_type.table end
+    alias_method :that_table_type, :type
+    def that_record_type() that_table_type.record_type end
+
+    # The link table between the two tables
+    def mm_table() mm_table_type.table end
+    def mm_record_type() mm_table_type.record_type end
+    attr_reader :mm_table_type
+
+    # Postgres column in the NM table that links to this table. This is
+    # typically the '<this-table>_id' column
+    attr_reader :this_mm_column
+
+    # Postgres column in the NM table that links to the embedding record. This
+    # is typically the '<that-table>_id' column
+    attr_reader :that_mm_column
+
+    # :unique in this context means that the associated records of this column
+    # are unique
+    def initialize(
+        record_type, name, that_table_type, mm_table_type,
+        this_link_column, this_mm_column, that_mm_column, that_link_column,
+        **opts)
+
+#     puts "MmTableColumn#initialize"
+#     indent {
+#       puts "record: #{record_type}"
+#       puts "column: #{name}"
+#       puts this_mm_column
+#       puts this_link_column
+#       puts that_mm_column
+#       puts that_link_column
+#     }
+
+      constrain record_type, RecordType
+      constrain that_table_type, TableType
+      constrain mm_table_type, TableType
+      mm_table_type.table.mm_table? or raise Error, "Link table expected"
+      super(record_type, name, that_table_type, this_link_column, that_link_column, **opts)
+      @mm_table_type = mm_table_type
+      @this_mm_column = this_mm_column
+      @that_mm_column = that_mm_column
+    end
+  end
+
+  class NmTableColumn < MmTableColumn
+    alias_method :nm_table, :mm_table
+    alias_method :nm_record_type, :mm_record_type
+    alias_method :nm_table_type, :mm_table_type
+    alias_method :this_nm_column, :this_mm_column
+    alias_method :that_nm_column, :that_mm_column
+  end
+end
+

data/pg_graph.gemspec

@@ -0,0 +1,40 @@
+require_relative 'lib/pg_graph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pg_graph"
+  spec.version       = PgGraph::VERSION
+  spec.authors       = ["Claus Rasmussen"]
+  spec.email         = ["claus.l.rasmussen@gmail.com"]
+
+  spec.summary       = %q{Create graph type model of database}
+  spec.description   = %q{dwpg_graph gem}
+  spec.homepage      = "http://www.nowhere.com/"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # spec.add_dependency GEM [, VERSION]
+  spec.add_dependency "boolean"
+  spec.add_dependency "constrain"
+  spec.add_dependency "developer_exceptions"                                                                         
+  spec.add_dependency "dry-inflector"
+  spec.add_dependency "hash_tree", "= 0.1.1"
+  spec.add_dependency "indented_io"
+  spec.add_dependency "shellopts", "2.0.6"
+
+  spec.add_dependency "pg_conn", "= 0.2.1"
+  spec.add_dependency "pg_meta", "0.1.0"
+
+  # Also un-comment in spec/spec_helper to use simplecov
+  # spec.add_development_dependency "simplecov"
+end

data/snippets/1-1.sql

@@ -0,0 +1,19 @@
+
+\connect postgres
+
+drop database if exists pg_graph;
+create database pg_graph;
+
+\connect pg_graph
+
+create table pictures (
+  id integer generated by default as identity primary key,
+  title text not null,
+  file text
+);
+
+create table blobs (
+  id integer not null references pictures(id) primary key,
+  blob text not null
+);
+

data/snippets/N-M.sql

@@ -0,0 +1,24 @@
+
+\connect postgres
+
+drop database if exists pg_graph;
+create database pg_graph;
+
+\connect pg_graph
+
+create table roles (
+  id integer generated by default as identity primary key,
+  name text not null
+);
+
+create table users (
+  id integer generated by default as identity primary key,
+  name text not null
+);
+
+create table user_roles (
+  id integer generated by default as identity primary key,
+  role_id integer not null references roles(id),
+  user_id integer not null references users(id)
+);
+