pg_graph 0.1.0

data/lib/pg_graph/timer.rb

@@ -0,0 +1,119 @@
+
+module Timer
+  class TimerNode
+    attr_reader :timer
+    attr_reader :label
+
+    def initialize(timer, label)
+      @timer, @label = timer, label
+    end
+
+    def label_width() label&.size || 0 end
+    def value_width() raise NotThis end
+
+    def total() raise NotThis end
+
+  protected
+    def format(time) sprintf "%.#{timer.scale}f", timer.factor * time end
+  end
+
+  class TimerElement < TimerNode
+    attr_accessor :time
+
+    def initialize(timer, label, time)
+      super(timer, label)
+      @time = time
+    end
+
+    def value_width() value.size end
+    def value() @value ||= format time end
+
+    def total() @time end
+
+  protected
+    def dump_element(file, indent, label_width, value_width)
+      file.printf "#{indent}%-#{label_width}s: %#{value_width}s#{timer.unit}\n", label, value
+    end
+  end
+
+  class TimerGroup < TimerNode
+    attr_accessor :unit # Currently only :s, or :ms. Default is :ms
+    def factor() { s: 1, ms: 1000 }[unit] end
+    attr_accessor :scale # Number of digits after the decimal point
+    attr_reader :nodes # Array of tuples of label and time or TimerGroup objects
+
+    def initialize(timer, label = nil, unit: :ms, scale: 2)
+      super(timer, label)
+      @unit = unit.to_sym
+      @scale = scale
+      @nodes = []
+      @nodes_by_label = {}
+    end
+
+    def time(label, &block)
+      t0 = Time.now
+      r = yield
+      dt = Time.now - t0
+      if @nodes_by_label.key?(label)
+        @nodes_by_label[label].time += dt
+      else
+        element = TimerElement.new(self, label, dt)
+        @nodes << element
+        @nodes_by_label[label] = element
+      end
+      r
+    end
+
+    def group(label, **opts)
+      r = TimerGroup.new(self, label, **{ unit: unit, scale: scale }.merge(opts))
+      @nodes << r
+      r
+    end
+
+    def total()
+      @nodes.inject(0) { |a,e| a + e.total }
+    end
+
+    def dump(file = $stdout, indent = "")
+      dump_element(file, indent, label_width, value_width)
+    end
+
+  protected
+    def label_width()
+      if label
+        ([label.size - 2] + @nodes.map { |node| node.send(:label_width) }).max + 2
+      else
+        @nodes.map { |node| node.send :label_width }.max
+      end
+    end
+
+    def value_width() @value_width ||= @nodes.map { |node| node.send :value_width }.max end
+
+    def dump_element(file, indent, label_width, value_width)
+      if label
+        file.puts "#{indent}#{label} (#{format(total)}#{timer.unit})"
+        nodes.each { |node|
+          node.send :dump_element, file, indent + "  ", label_width - 2, value_width
+        }
+      else
+        nodes.each { |node|
+          node.send :dump_element, file, indent, label_width, value_width
+        }
+      end
+    end
+  end
+
+  class Timer < TimerGroup
+    def initialize(label = nil, **opts)
+      super(self, label, **opts)
+    end
+
+    def dump(file = $stdout)
+      super
+      if @nodes.size > 1
+        file.printf "%-#{label_width}s: %#{value_width}s#{timer.unit}\n", "Total", format(total)
+      end
+    end
+  end
+end
+

data/lib/pg_graph/version.rb

@@ -0,0 +1,3 @@
+module PgGraph
+  VERSION = "0.1.0"
+end

data/lib/pg_graph.rb

@@ -0,0 +1,124 @@
+
+require "pg_graph/version"
+
+require "boolean"
+require "constrain"
+#def constrain(*args) end
+require "developer_exceptions"
+
+require "hash_tree"
+
+require "ext/meta.rb"
+require "ext/module.rb"
+
+require "pg_graph/version.rb"
+require "pg_graph/inflector.rb"
+require "pg_graph/reflector.rb"
+
+require "type/type.rb"
+require "type/read.rb"
+require "type/dump_type.rb"
+
+require "data/data.rb"
+require "data/association.rb"
+require "data/value.rb"
+require "data/dimension.rb"
+require "data/read.rb"
+require "data/render.rb"
+
+module PgGraph
+  include DeveloperExceptions
+
+  class Error < StandardError; end
+
+  # The supported ruby classes
+  RUBY_CLASSES = Inflector::SUPPORTED_RUBY_CLASSES
+
+  module Type
+    # :call-seq:
+    #   new(meta, reflect = nil)
+    #   new(pg_conn, reflect = nil)
+    #
+    # The +reflect+ argument can be a Reflector object, an yaml array, a file
+    # name or nil. The +ignore+ option is a list of schema names to exclude
+    # from the type system
+    #
+    # Note that together with ::=== and Database#is_a? this makes
+    # Type::Database pretend it is an instance of the Type module
+    #
+    def self.new(arg, reflect = nil, ignore: [])
+      constrain arg, PgMeta, PgConn
+      constrain reflect, Reflector, Array, String, NilClass
+      meta = 
+          case arg
+            when PgMeta; arg
+            when PgConn; PgMeta.new(arg)
+          end
+      reflector = 
+          case reflect
+            when Reflector; reflect
+            when Array; Reflector.load_yaml(reflect)
+            when String; Reflector.load_file(reflect)
+            when NilClass; Reflector.new
+          end
+      Database.new(meta.name, reflector).read(meta, ignore: ignore)
+    end
+
+    # Make the Type module pretend to have Database object instances
+    def self.===(element) element.is_a?(PgGraph::Type::Connection) or super end
+
+    class Database
+      # :call-seq:
+      #   instantiate()
+      #   instantiate(hash)
+      #   instantiate(yaml)
+      #   instantiate(pg_conn)
+      #   
+      def instantiate(arg = nil)
+        constrain arg, NilClass, Hash, PgConn
+        Data.new(self, arg)
+      end
+
+      # Let Type::Database objects pretend to be-a module Type object
+      def is_a?(arg) arg == PgGraph::Type || super end
+    end
+  end
+
+  module Data
+    # :call-seq:
+    #   new(type, hash = {})
+    #   new(type, yaml = {})
+    #   new(type, pg_conn = nil)
+    # 
+    # Note that together with ::=== and Data::Database#is_a? this makes
+    # Data::Database pretend it is an instance of the Data module
+    def self.new(type, arg)
+      constrain type, PgGraph::Type
+      constrain arg, Hash, PgConn, NilClass
+      Database.new(type, arg)
+    end
+
+    # Make the Data module pretend to have Database object instances
+    def self.===(element) element.is_a?(PgGraph::Data::Connection) or super end
+
+    class Database
+      # Let Data::Database objects pretend to be-a module Type object
+      def is_a?(arg) arg == PgGraph::Data || super end
+    end
+  end
+
+  # Non-public namespace
+  module PrivatePgGraph
+    # Note that this changes the +args+ argument
+    def self.extract_reflections(args)
+      if args.last.is_a?(Hash)
+        reflections = args.last.delete(:reflections) || []
+        args.pop if args.last.empty? && !reflections.empty?
+        reflections
+      else
+        []
+      end
+    end
+  end
+end
+

data/lib/type/dump_type.rb

@@ -0,0 +1,69 @@
+require 'indented_io'
+
+module PgGraph::Type
+  class Node
+    def dump(children = self.children.values.sort_by(&:name), link_info: false, supertable: nil)
+      print identifier + (supertable ? " < #{supertable}" : "")
+      puts
+      indent { children.each { |child| child.dump(link_info: link_info) } }
+    end
+  end
+
+  class Schema
+    def dump(link_info: false)
+      super(record_types.sort_by(&:name), link_info: link_info)
+    end
+  end
+
+  class RecordType
+    def dump(**opts)
+      supertable = table.supertable&.identifier
+      columns = fields.reject { |column|
+        column.primary_key? || column.name =~ /_id$/ || column.name =~ /_kind$/ # FIXME
+      }
+      super(columns, supertable: supertable, **opts)
+    end
+  end
+
+  class Column
+    def dump(link_info: false)
+      print "#{identifier}: "
+      method = type.schema == record_type.schema ? :identifier : :schema_identifier
+      if self.is_a?(MmTableColumn) && !self.is_a?(NmTableColumn)
+        type_identifier = "{[#{type.element_type.send(method)}]}"
+      else
+        type_identifier = type.send(method)
+      end
+      print type_identifier
+      print "()" if generated?
+      print "[#{that_link_column}]" if kind?
+      print "?" if nullable?
+      print "!" if unique?
+      dump_type if link_info
+      puts
+    end
+
+    def dump_type() end
+  end
+
+  class RecordColumn
+    def dump_type
+      print " (#{this_link_column} -> #{type.table.name}.#{that_link_column}) (RecordColumn)"
+    end
+  end
+
+  class TableColumn
+    def dump_type
+      print " (#{this_link_column} -> #{type.table.name}.#{that_link_column}) (TableColumn)"
+    end
+  end
+
+  class MmTableColumn
+    def dump_type
+      print \
+          " (#{this_link_column} -> #{mm_table.name}.#{this_mm_column}," +
+          " #{mm_table.name}.#{that_mm_column} -> #{that_table.name}.#{that_link_column}) (MmTableColumn)"
+    end
+  end
+end
+

data/lib/type/read.rb

@@ -0,0 +1,269 @@
+module PgGraph::Type
+  class Error < StandardError; end
+  class KeyNotFound < Error; end
+
+  class Database
+    def read_meta(meta, ignore: [])
+      # Array of [record, meta_column] tuples
+      field_columns = []
+      link_columns = []
+      kind_columns = [] # The link side 
+      id_link_columns = [] # sub tables
+
+      # Temporary arrays of meta tables
+      tables = [] # Ordinary tables
+      mm_tables = [] # M:M link tables
+
+      # Create schemas and tables and initialize lists of objects
+      meta.schemas.values.each { |meta_schema|
+        next if ignore.include?(meta_schema.name)
+        schema = Schema.new(self, meta_schema.name)
+        meta_schema.tables.values.select { |t| t.table? }.each { |meta_table| # FIXME Ignore views for now
+          (meta_table.mm_table? ? mm_tables : tables) << meta_table
+          table = Table.new(
+              schema, meta_table.name, 
+              mm_table: meta_table.mm_table?,
+              depending_materialized_views: meta_table.depending_views.select(&:materialized?))
+          record_type = RecordType.new(table)
+
+          # Process columns
+          array_columns = []
+          meta_table.columns.values.each { |meta_column|
+            # Create basic types needed by columns
+            type_name = meta_column.type
+            if !schema.key?(type_name) && !catalog.key?(type_name)
+              if meta_column.array? 
+                element_name = meta_column.element_type
+                dimensions = meta_column.dimensions
+                if !schema.key?(element_name) && !catalog.key?(element_name)
+                  element_type = SimpleType.new(catalog, element_name)
+                else
+                  element_type = schema[element_name] || catalog[element_name]
+                end
+                ArrayType.new(catalog, type_name, element_type, dimensions)
+              else
+                SimpleType.new(catalog, type_name)
+              end
+            end
+
+            # Collect columns
+            if meta_column.reference?
+              if meta_column.name == "id"
+                id_link_columns
+              elsif meta_column.name =~ /^(?:.*_)?kind$/
+                kind_columns 
+              else
+                link_columns
+              end
+            else
+              field_columns
+            end << [record_type, meta_column]
+          }
+        }
+      }
+
+      # Build list of depending tables
+      (tables + mm_tables).each { |meta_table|
+        table = dot(meta_table.path)
+        meta_table.depending_tables.each { |meta_depending_table|
+          depending_table = dot(meta_depending_table.path)
+          table.depending_tables << depending_table
+#         puts "#{table.uid} -> #{depending_table.uid}"
+        }
+
+      }
+
+      # Create postgres columns except kind_columns
+      (id_link_columns + link_columns + field_columns).each { |record_type, meta_column|
+        next if meta_column.kind?
+        type = record_type.schema[meta_column.type] || catalog[meta_column.type]
+        SimpleColumn.new(
+            record_type, meta_column.name, meta_column.name, type, 
+            ordinal: meta_column.ordinal,
+            **column_options(meta_column))
+      }
+
+
+      # Create and collect forward-references. link_fields is a list of [uid, record_column] tuples
+      link_fields = []
+      (link_columns + kind_columns).each { |record_type, meta_column|
+        meta_column.references.each { |constraint|
+          constraint.referencing_columns.size == 1 or raise Error, "Can't handle multi-column keys (for now)"
+          type = dot(constraint.referenced_table.path).type.record_type
+          this_link_column = constraint.referencing_columns.first.name
+          that_link_column = constraint.referenced_columns.first.name
+
+          field = 
+              if meta_column.kind?
+                name = reflector.this(meta_column.uid) || meta_column.name
+                name = meta_column.name if record_type[name] # Check for duplicates
+                !record_type.nil? or raise Error, "Duplicate column name: #{name}" # Check again
+                column_type = record_type.schema[meta_column.type] || catalog[meta_column.type]
+
+                parent = (name != meta_column.name ? record_type : nil)
+                kind_column = SimpleColumn.new(
+                    parent, meta_column.name, meta_column.name, column_type,
+                    ordinal: meta_column.ordinal,
+                    **column_options(meta_column))
+
+                KindRecordColumn.new(
+                    record_type, name, meta_column.name, type, this_link_column, that_link_column,
+                    kind_column, **column_options(meta_column))
+              else
+                name = reflector.this(meta_column.uid)
+                RecordColumn.new(
+                    record_type, name, meta_column.name, type, this_link_column, that_link_column,
+                    **column_options(meta_column))
+              end
+          link_fields << [meta_column.uid, field]
+        }
+      }
+
+      # Detect derived tables
+#     link_fields.each { |uid, record_column|
+#       if record_column.this_link_column.primary_key? && that_link_column.primary_key?
+
+      # Create back-reference fields
+      (link_fields).each { |uid, this_column|
+        this_record_type = this_column.record_type
+        this_table = this_record_type.table
+        that_record_type = this_column.type
+        next if this_table.mm_table?
+
+        # Field name of back-reference
+        if this_column.primary_key? # child record
+          this_column.postgres_column == "id" or raise Error, "Primary keys should be named 'id'"
+          name = this_record_type.name
+        else
+          name = reflector.that(uid, this_column.unique?, table: this_record_type.name)
+          name ||= PgGraph.inflector.pluralize(this_column.table.name) if this_column.kind?
+        end
+
+        next if name.nil?
+
+        # Check for name collisions
+        if that_record_type.key?(name)
+          # Check if this is a 1:1 relation with keys on both sides. In that
+          # case, the back-reference is already created
+          that_column = that_record_type[name]
+          if that_column.is_a?(RecordColumn) && that_column.type == this_record_type
+            next # Do nothing
+
+          # Check if the reference spans across schemes so we can disambiguate
+          # by prefixing the schema name
+          elsif this_column.table.schema != that_column.table.schema
+            name = "#{this_column.table.schema.name}_#{name}"
+          end
+        end
+
+        # Final check for name collisions
+        !that_record_type.key?(name) or
+            raise Error, "Name collision in reverse map for #{this_column.uid}, trying #{name}"
+
+        # Create back-references
+        if this_column.unique?
+          RecordColumn.new(
+              that_record_type, name, nil, this_record_type, 
+              this_column.that_link_column, this_column.this_link_column)
+        else
+          TableColumn.new(that_record_type, name, this_table.type,
+              this_column.that_link_column, this_column.this_link_column)
+        end
+      }
+
+      # Setup super/subtables
+      id_link_columns.each { |this_record_type, meta_column|
+        # Create forward and backward references for id links
+        constraint = meta_column.references.first
+        that_record_type = dot(constraint.referenced_table.path).type.record_type
+        SuperRecordColumn.new(this_record_type, that_record_type)
+        SubRecordColumn.new(that_record_type, this_record_type)
+
+        # Create hierarchy
+        this_table = this_record_type.table
+        that_table = that_record_type.table
+        this_table.instance_variable_set(:@supertable, that_table)
+        that_table.instance_variable_set(:@has_subtables, true)
+      }
+
+      # Create N:M or M:M reference fields
+      mm_tables.each { |link_meta_table|
+        constraint1 = link_meta_table.referential_constraints.values[0]
+        constraint2 = link_meta_table.referential_constraints.values[1]
+        table1 = dot(constraint1.referenced_table.path)
+        table2 = dot(constraint2.referenced_table.path)
+        mm_table = dot(link_meta_table.path)
+
+        link_column1 = constraint1.referenced_columns.first.name
+        mm_column1 = constraint1.referencing_columns.first.name
+        mm_column1_uid = constraint1.referencing_columns.first.uid
+
+        link_column2 = constraint2.referenced_columns.first.name
+        mm_column2 = constraint2.referencing_columns.first.name
+        mm_column2_uid = constraint2.referencing_columns.first.uid
+
+        column1_name = reflector.that(mm_column1_uid, false, table: table2.record_type.name)
+        column2_name = reflector.that(mm_column2_uid, false, table: table1.record_type.name)
+
+        # FIXME: DAGs over an super table creates problems if reflections
+        # doesn't match (eg. role_id/group_id instead of
+        # child_group_id/parent_group_id)
+
+        # Detect DAGs. This check is performed after column names have been
+        # computed to allow for user defined reflections
+#       if column1_name == column2_name && table1 == table2
+#         column1_name = reflector.that(mm_column1_uid, false)
+#         column2_name = reflector.that(mm_column2_uid, false)
+#         puts "BINGO"
+#         puts column1_name
+#         puts column2_name
+#         exit 1
+#       else
+#       end
+
+
+#       puts "mm_tables.each"
+#       indent {
+#         puts "mm_column1_uid: #{mm_column1_uid}"
+#         puts "mm_column2_uid: #{mm_column2_uid}"
+#         puts "table1: #{table1}"
+#         puts "column1_name: #{column1_name}"
+#         puts "table2: #{table2}"
+#         puts "column2_name: #{column2_name}"
+#       }
+
+        if table1.type.record_type.key?(column1_name)
+          raise Error, "Duplicate column name in #{table1.identifier}: #{column1_name}"
+        end
+          
+        if table2.type.record_type.key?(column2_name)
+          raise Error, "Duplicate column name in #{table2.identifier}: #{column2_name}"
+        end
+
+        klass = link_meta_table.nm_table? ? NmTableColumn : MmTableColumn
+        klass.new(
+            table1.type.record_type, column1_name, table2.type, mm_table.type,
+            link_column1, mm_column1, mm_column2, link_column2)
+        klass.new(
+            table2.type.record_type, column2_name, table1.type, mm_table.type,
+            link_column2, mm_column2, mm_column1, link_column1)
+      }
+
+      self
+    end
+
+  private
+    # Create a options Hash for ColumnField objects
+    def column_options(meta_column)
+      {
+        primary_key: meta_column.primary_key?,
+        identity: meta_column.identity?,
+        nullable: meta_column.nullable?,
+        unique: meta_column.unique?,
+        readonly: !meta_column.updatable? || meta_column.generated?,
+        generated: meta_column.generated?
+      }
+    end
+  end
+end
+