pg_graph 0.1.0

data/lib/data/data.rb

@@ -0,0 +1,551 @@
+require 'constrain'
+require 'yaml'
+
+include Constrain
+
+module PgGraph::Data
+  class Error < StandardError; end
+
+  class Node
+    # Type of the node (a PgGraph::Type::Node object)
+    attr_reader :type
+
+    # Type of the value of a node
+    def value_type() type end
+
+    # Dimension of the node
+    attr_reader :dimension
+
+    def initialize(type, dimension: nil)
+      constrain type, PgGraph::Type::Node
+      Dimension.validate(dimension) if dimension
+      @type = type
+      @dimension = dimension
+    end
+
+    # Node converted to plain ruby objects structured as given by #dimension.
+    # This is the same as #value except for M:M associations
+    def data() @impl end
+
+    # Node converted to plain ruby objects structured as given by the dimension
+    # kind but with flattened M:M associations so duplicates can happen
+    def value() data end
+
+    # Usually the node itself but associations redefines this to be the
+    # associated object. It is used in client code to reference the value
+    # object of an associated field, ie: +node.object.value()+ will give you the
+    # value of a field even if the field is an association
+    def object() self end
+
+    def inspect(payload = inspect_inner) 
+      "#<#{self.class}:#{uid}#{payload ? " #{payload}" : ""}>" 
+    end
+
+    def to_h() raise NotThis end
+    def to_yaml() raise NotThis end
+
+  protected
+    def inspect_inner() nil end
+  end
+
+  class DatabaseObject < Node
+    # The database (Data::Database) of this objectD. It is defined "globally"
+    # because #dot requires quick access to the containing database
+    def database() raise NotThis end
+
+    # Unique id within a database. Note that #uid has to be defined before
+    # #initialize is called as it uses the UID as a key in the database-wide
+    # lookup table
+    def uid() type.uid end
+
+    # Global unique id including database
+    def guid() type.guid end
+
+    # Name of object. Defaults to the name of the type
+    def name() type.name end
+
+    def initialize(*args, **opts)
+      super
+      database.send(:add_object, self)
+    end
+
+    def dot(path) database.dot["#{uid}.#{path}"] end
+#   def ==(other) raise PgGraph::NotThis end
+    def <=>(other) uid <=> other.uid end
+  end
+
+  class Database < DatabaseObject
+    # Redefine DatabaseObject#database to return self
+    def database() self end
+
+    # List of Schema objects
+    def schemas() @impl.values end
+
+    # +data_source+ can be a PgConn object, a Hash, or nil
+    def initialize(type, data_source = nil)
+      constrain type, PgGraph::Type::Database
+      constrain data_source, PgConn, Hash, NilClass
+      @queued_objects = [] # has to go before super
+      @objects = nil # Object cache. Maps from UID to object. Has to go before super
+      super(type)
+      initialize_impl
+      read(data_source) if data_source
+    end
+
+    def dup() Database.new(type, to_h) end
+    
+    # Make Database pretend it is a PgGraph::Data object
+    def is_a?(klass) klass == PgGraph::Type or super end
+
+    # Get schema by name
+    forward_to :@impl, :[]
+
+    # Iterate schemas
+    def each(&block) schemas.each { |schema| yield schema } end
+
+    # Return database as a hash from schema name to schema hash
+    def data() @impl.map { |k,v| [k, v.data] }.to_h end
+
+    # Return object by the given UID
+    def dot(uid) @objects ||= map_objects[uid] end
+
+    # TODO: Maybe use this instead of #dot
+    def lookup(path, id = nil)
+      object = (@objects ||= map_objects)[path]
+      id.nil? ? object : object[id]
+    end
+
+    def ==(other) to_h == other.to_h end 
+
+    alias_method :to_h, :data
+
+    # The #to_yaml format is like #to_h but with records formatted as an array
+    # instead of as a map from ID to record
+    def to_yaml() @impl.map { |k,v| [k, v.to_yaml] }.to_h end
+
+    # Note that #to_sql in derived classes should be deleted FIXME
+    def to_sql(format: :sql, ids: {}, delete: :all, files: [])
+      render = SqlRender.new(self, format, ids: ids, delete: delete, files: files)
+      render.to_s
+    end
+
+    def to_exec_sql(ids: {}, delete: :all) 
+      to_sql(format: :exec, ids: ids, delete: delete) 
+    end
+
+    def to_psql_sql(files = [], ids: {}, delete: :all) 
+      to_sql(format: :psql, ids: ids, delete: delete, files: files) 
+    end
+
+    # :call-seq:
+    #   read(connection)
+    #   read(hash)
+    #   read(yaml)
+    #
+    # Read data from a source. Returns self
+    #
+    def read(arg)
+      constrain arg, PgConn, Hash
+      case arg
+        when PgConn; read_connection(arg)
+        when Hash; read_hash(arg)
+      end
+      self
+    end
+
+    # Write data to database. +ids+ is a hash from table UID to id. If a record
+    # has an ID equal to or less than the corresponding ID in +ids+, the SQL
+    # will be rendered as an 'update' statement instead of an 'insert'
+    # statement. Returns self
+    def write(connection, ids: {}, delete: :all)
+      constrain connection, PgConn
+      constrain ids, String => Integer
+      connection.exec(to_exec_sql(ids: ids, delete: :all))
+      self
+    end
+
+  private
+    # Sets up a database with empty tables
+    def initialize_impl
+      @impl = {} # Hash from schema name to Schema object
+      type.schemas.each { |schema| @impl[schema.name] = Schema.new(self, schema) }
+      schemas.each { |schema| schema.tables.each { |table| table.initialize_associations } }
+    end
+
+    def add_object(object)
+      @queued_objects << object
+    end
+
+    def map_objects()
+      r = @queued_objects.map { |object| [object.uid, object] }.to_h
+      @queued_objects = []
+      r
+    end
+  end
+
+  class Schema < DatabaseObject
+    attr_reader :database
+
+    # List of Table objects
+    def tables() @impl.values end
+
+    def initialize(database, type)
+      constrain database, Database
+      constrain type, PgGraph::Type::Schema
+      @database = database
+      super(type)
+      @impl = {} # A hash from table name to Table object
+      type.tables.each { |table| @impl[table.name] = Table.new(self, table) }
+    end
+
+    # Get table by name
+    forward_to :@impl, :[]
+
+    # Iterate tables
+    def each(&block) tables.each { |table| yield table } end
+
+    # Return schema as a hash from table name to table hash
+    def data() @impl.map { |k,v| [k, v.data] }.to_h end
+
+    alias_method :to_h, :data
+#   def to_sql() 
+#     tables.select { |table| !table.empty? }.map(&:to_sql).join("\n") 
+#   end
+    def to_yaml() @impl.map { |k,v| [k, v.to_yaml] }.to_h end
+  end
+
+  # Note that Query objects have the same name as the referenced table but
+  # different UID. Queries are not included in the schemas list of tables
+  class Table < DatabaseObject
+    # Redefine DatabaseObject#database
+    def database() schema.database end
+
+    # Schema of table
+    attr_reader :schema
+
+    # Cached association objects. Map from record or table field name to
+    # Association object. Associations are cached in Table because they have
+    # non-trivial constructors. Initialized by #initialize_associations
+    attr_reader :associations
+
+    # List of Record objects (including duplicates)
+    def records() @impl.values end
+
+    def initialize(schema, type, dimension: 2)
+      constrain schema, Schema
+      constrain type, PgGraph::Type::Table
+      @schema = schema
+      super(type, dimension: dimension)
+      @impl = {} # A table is implemented as a hash from integer ID to Record object
+      @associations = {} # initialized by #initialize_associations
+    end
+
+    def initialize_associations
+      db = schema.database
+      type.fields.each { |column|
+        next if column.is_a?(PgGraph::Type::SimpleColumn)
+        that_table = db[column.type.schema.name][column.type.table.name]
+        association = 
+            case column
+              when PgGraph::Type::KindRecordColumn
+                KindAssociation.new(1,
+                    self, that_table, 
+                    column.this_link_column.to_sym, 
+                    column.that_link_column.to_sym)
+              when PgGraph::Type::RecordColumn
+                Association.new(1, 
+                    self, that_table, 
+                    column.this_link_column.to_sym, 
+                    column.that_link_column.to_sym)
+              when PgGraph::Type::NmTableColumn, PgGraph::Type::MmTableColumn
+                dimension = column.is_a?(PgGraph::Type::NmTableColumn) ? 2 : 3
+                nm_table = db[column.mm_table.schema.name][column.mm_table.name]
+                LinkAssociation.new(dimension, 
+                    self, that_table, nm_table,
+                    column.this_link_column.to_sym, column.this_mm_column.to_sym, 
+                    column.that_mm_column.to_sym, column.that_link_column.to_sym)
+              when PgGraph::Type::TableColumn
+                Association.new(2, 
+                    self, that_table, 
+                    column.this_link_column.to_sym, 
+                    column.that_link_column.to_sym)
+            else
+              raise NotHere
+            end
+        @associations[column.name.to_sym] = association
+      }
+    end
+
+    # Number of records in the table (including duplicates)
+    def size() records.size end
+
+    # True if table is empty
+    def empty?() @impl.empty? end
+
+    # Return record with the given ID
+    def [](id) @impl[id] end
+     
+    # True if the table contains a record with the given ID
+    def id?(id) @impl.key?(id) end
+
+    # List of record IDs (excluding duplicates)
+    def ids() @impl.keys end
+
+    # Max. record ID. Equal to 0 if the table is empty
+    def max_id() @max_id ||= (@impl.keys.max || 0) end
+
+    # :call-seq:
+    #   select(id, &block)
+    #   select(ids, &block)
+    #
+    # Select a number of records given by an ID or an array of IDs. Returns a
+    # Record object in the first case and a TableSelect otherwise. The
+    # :dimension option can be set to 3 to get a MmTableSelect object
+    # instead
+    #
+    def select(arg = nil, dimension: nil, &block)
+      constrain arg, Integer, [Integer], NilClass
+      constrain dimension, Integer, NilClass
+      case arg
+        when Integer
+          candidates = [self[arg]]
+          dimension ||= 1
+        when Array
+          candidates = arg.map { |id| self[id] }.compact
+          dimension ||= 2
+        when NilClass
+          candidates = records
+          dimension ||= 2
+      end
+      candidates = candidates.select { |record| yield(record) } if block_given?
+      Dimension.value_class(dimension).new(self, candidates)
+    end
+
+    # Iterate records
+    def each(&block) @impl.values.each { |record| yield record } end
+
+    # Return table as a hash from record ID to record hash
+    def data() @impl.map { |k,v| [k, v.data] }.to_h end
+
+    alias_method :to_h, :data
+
+    def to_yaml() @impl.map { |k,v| v.to_h } end
+
+    def inspect_inner() "[" + records.map(&:inspect_inner).join(", ") + "])" end
+
+  protected
+    def add_record(record)
+      !@impl.key?(record.id) or raise "Duplicate record ID: #{record.id}"
+      @impl[record.id] = record
+    end
+  end
+
+  class Record < DatabaseObject
+    # Redefine UID to include ID of record
+    def uid() "#{table.uid}[#{id}]" end
+
+    def self.split_uid(uid)
+      uid =~ /^(.*?)\[(\d+)\]$/
+      [$1, $2.to_i]
+    end
+    
+    # Redefine GUID to include ID of record
+    def guid() "#{table.guid}[#{id}]" end
+
+    # Redefine name to be the record ID"
+    def name() id end
+
+    # Redefine DatabaseObject#database
+    def database() table.database end
+
+    # Table of record
+    attr_reader :table
+
+    # ID of record (Integer)
+    def id() @impl[:id].value end
+#   def id() @id end
+
+    def initialize(table, columns)
+      constrain table, Table
+      constrain columns, Symbol => PgGraph::RUBY_CLASSES
+      constrain columns, lambda { |h| h.key?(:id) }, "No :id field"
+      @table = table # has to go before super
+      super(table.type.record_type, dimension: 1)
+      @impl = columns.map { |k,v| [k, Column.new(self, k, v)] }.to_h 
+      for name, association in table.associations
+        if association.is_a?(KindAssociation) #&& @impl.key?(name)
+          next if !@impl.key?(name)
+          column = @impl.delete(name)
+          @impl[name] = KindRecordField.new(self, name, association, column)
+        else
+          !@impl.key?(name) or raise "Duplicate field: #{name}"
+          field_class = Dimension.field_class(association.dimension)
+          @impl[name] = field_class.new(self, name, association)
+        end
+      end
+#     puts "Record#initialize(#{table.uid.inspect}, #{columns.inspect})"
+#     puts "  columns: #{self.columns}"
+#     puts "  fields: #{fields}"
+#     puts "  names: #{names}"
+#     puts "  value_columns: #{value_columns}"
+      table.send(:add_record, self)
+    end
+
+    # Return Field object with the given name
+    def [](name) @impl[name.to_sym] end
+
+    # True if the record contains a field with the given name
+    def field?(name) @impl.key?(name.to_sym) end
+
+    # List of field names
+    def names() @impl.keys end
+
+    # List of Field objects in the record
+    def fields() @impl.values end
+
+    # List of Column objects in the record
+    def columns() @impl.values.select { |field| field.is_a?(Column) } end
+
+    # List of columns excluding generated columns
+    def value_columns() 
+      columns.select { |column| !column.type.generated? }.uniq
+    end 
+
+    # List of association objects in the record
+    def associations() @impl.values.select { |field| field.is_a?(AssociationField) } end
+
+    # Iterate fields
+    def each(&block) fields.each { |field| yield field } end
+
+    # Return data of record as a hash of from column name to value. Note that
+    # association fields are not included
+#   def data() @impl.select { |k,v| v.is_a?(Column) }.map { |k,v| [k, v.data] }.to_h end
+
+    def data()
+      @impl.select { |k,v| v.is_a?(Column) || v.is_a?(KindRecordField) }.map { |k,v| [k, v.data] }.to_h 
+    end
+
+    alias_method :to_h, :data
+
+    # FIXME: Is this in use?
+#   def to_sql()
+#     "(" + type.columns.map { |column_type|
+#       field?(column_type.name) ? self[column_type.name]&.to_sql || 'NULL' : 'DEFAULT'
+#     }.join(", ") + ")"
+#   end
+
+    def to_yaml() data end
+
+    def inspect_inner() "{" + columns.map(&:inspect_inner).join(', ') + "}" end
+  end
+
+  class Field < DatabaseObject
+    # Redefine #uid
+    def uid() "#{record.uid}.#{name}" end
+
+    # Redefine #uid
+    def guid() "#{record.guid}.#{name}" end
+
+    # Redefine #name to return a Symbol
+    def name() super.to_sym end
+
+    # Redefine DatabaseObject#database
+    def database() record.database end
+
+    # Record of field
+    attr_reader :record
+
+    def initialize(record, name, **opts)
+      constrain record, Record
+      constrain name, String, Symbol
+      @record = record # has to go before super
+      super(record.type[name.to_s], **opts)
+    end
+
+    def to_h() { name: value } end
+  end
+
+  class Column < Field
+    def initialize(record, name, value)
+      constrain value, *PgGraph::RUBY_CLASSES
+      super(record, name, dimension: 0)
+      @impl = value
+    end
+
+    # TODO: Escape sequences
+    # FIXME: Not in use (and WRONG!)
+    def to_sql
+      $stderr.puts "* SHOULDN'T BE CALLED IN DATA.RB **************************"
+      raise "Oops"
+      if value.nil?
+        'NULL'
+      else
+        if type.ruby_class <= Numeric
+          value
+        elsif type.ruby_class <= Array
+          if value.empty?
+            "'{}'"
+          else
+            "'{'#{value.join("', '")}'}"
+          end
+        else
+          "'#{PG::Connection.escape_string(value.to_s)}'"
+        end
+      end
+    end
+
+    def inspect() super value.inspect end
+    def inspect_inner() "#{name}: #{value.is_a?(String) ? "'#{value}'" : value.inspect}" end
+  end
+
+  class AssociationField < Field
+    forward_to :association, :dimension
+
+    # The table of the associated record(s)
+    def table() association.that_table end
+
+    # The association object
+    attr_reader :association
+
+    def initialize(record, name, association)
+      constrain association, Association
+      super(record, name, dimension: association.dimension)
+      @association = association
+    end
+
+    # Return the value of the association. This is either a Record, TableValue,
+    # or MmTableValue depending on the dimension of the association
+    def object()
+      @object ||= Dimension.value_class(dimension).new(table, association.get_records(record)) 
+    end
+  end
+
+  class RecordField < AssociationField
+    forward_to :object, :id, :[], :field?, :names, :fields, :columns, :associations, :value, :data, :to_h
+  end
+
+  class KindRecordField < RecordField
+    def initialize(record, name, association, column)
+      constrain column, Column
+      super(record, name, association)
+      @column = column
+    end
+      
+    def value_type() @column.value_type end
+    def value() @column.value end
+    def data() @column.data end
+  end
+
+  class TableField < AssociationField
+    forward_to :object, :schema, :records, :size, :empty?, :[], :id?, :ids, :value, :data, :associations
+  end
+
+  class MmTableField < AssociationField
+    forward_to :object, :schema, :records, :size, :empty?, :[], :id?, :ids, :value, :data, :associations, :count
+  end
+end
+
+
+
+
+

data/lib/data/dimension.rb

@@ -0,0 +1,51 @@
+module PgGraph::Data
+  # Dimension of the node (corresponding kind shown in parenthesis):
+  #
+  #   0   A single value (:value)
+  #   1   A single record (:record)
+  #   2   A map from id to record (:table)
+  #   3   A map from id to array of duplicate records (:table)
+  # 
+  # The dimension defines class and structures of GraphData objects
+  #
+  class Dimension
+    def self.valid?(dimension, min: 0)
+      dimension.is_a?(Integer) && (min..3).include?(dimension) 
+    end
+
+    def self.kind(dimension)
+      case dimension
+        when 0; :value
+        when 1; :record
+        when 2, 3; :table
+      end
+    end
+
+    def self.field_class(dimension)
+      validate(dimension)
+      case dimension
+        when 0; Column
+        when 1; RecordField
+        when 2; TableField
+        when 3; MmTableField
+      end
+    end
+
+    def self.value_class(dimension)
+      validate(dimension, min: 1)
+      case dimension
+        when 1; RecordValue
+        when 2; TableValue
+        when 3; MmTableValue
+      end
+    end
+
+    def self.validate(dim, min: 0, unwind: 1)
+      constrain dim, Integer, unwind: unwind
+      constrain dim, 
+          lambda { |d| Dimension.valid?(d, min: min) }, 
+          "Out of range value: #{dim}", 
+          unwind: unwind
+    end
+  end
+end

data/lib/data/read.rb

@@ -0,0 +1,44 @@
+
+require 'pg_conn'
+
+module PgGraph::Data
+  class Database
+    # load data from connection
+    def read_connection(conn)
+      constrain conn, PgConn::Connection
+      initialize_impl
+      for schema in type.schemas
+        for table in schema.tables
+          for record in conn.records("select * from #{table.uid}")
+            Record.new(self[schema.name][table.name], record)
+          end
+        end
+      end
+      self
+    end
+
+    # load data from hash. The hash can be produced by #to_h or #to_yaml
+    #
+    # TODO: Check for unknown keys
+    def read_hash(hash)
+      constrain hash, Hash
+      initialize_impl
+
+      # Works on to #to_h and #to_yaml hashes because it is easier to handle
+      # the two formats dynamically than detecting which format to use
+      for schema in type.schemas
+        next if !hash.key?(schema.name)
+        hash_schema = hash[schema.name]
+        for table in schema.tables
+          next if !hash[schema.name].key?(table.name)
+          hash_table = hash_schema[table.name]
+          records = hash_table.is_a?(Hash) ? hash_table.values : hash_table
+          for record in records
+            Record.new(self[schema.name][table.name], record)
+          end
+        end
+      end
+      self
+    end
+  end
+end