pg_graph 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49b8ffc6fb32516ede1d4f33e9c4b4cf06d3966a279eebd3a137959c6da5e37c
-  data.tar.gz: b08ba8c452e083f1ae581387bc88bc9acea229a0e416b6f935d10e453753e2e9
+  metadata.gz: ea523768bdb76ecb1e4d8a8cee3d1b4afbad3e5735964acf63f78d5152050cf5
+  data.tar.gz: a29f1abbbdb5b674090a503c9db9ab0357140035b2c5af62a07352d38d5f3009
 SHA512:
-  metadata.gz: 7def3f805b7404546af5cdc8d524d14d177e2619b077baeadc513f94b5559d09a8cf7764269e2323acc8944e17132f9db559db4c518cc3f55246c6ad95105cab
-  data.tar.gz: 32e6f9e13430873f529ef91a2a350407abe7bdf6588fa45b2781a566466d8e7dca3276f6af91c7b56007c1a8b709f1de83fae82cda156dc576bc7565113fb224
+  metadata.gz: ad4d4f581462c3b982d7e7504a6277e7585e1d422974a6058ca9ba54c4e30ed48ba5ba38e88504d449caa8690c7664a46366187e2ceab7e19a2f8f26abb944ac
+  data.tar.gz: fff6a163e030d2dfd1187c07e6e69d0da9dbef18b4c0ef2fda393dfe7f9725e61c21f47febed69199b553b17f0285f16c30951e623e0143f0dd37d302228fd8b

data/exe/pg_graph

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+#$LOAD_PATH.unshift "/home/clr/prj/shellopts/lib"
+
 require 'shellopts'
 require 'pg_graph.rb'
 require "pg_graph/timer.rb"
@@ -32,9 +34,23 @@ SPEC = %(
     Make pg_graph loads its meta data from a marshalled PgMeta object instead
     of quering the database
 
+  +i,ignore=SCHEMA
+    Exclude objects in the given schema. This option can be repeated
+
   -r,reflections=EFILE
     Load reflections from FILE
 
+  -t,reflections-table=TABLE_UID?
+    Read/write reflections in the given table. The table argument can be both a
+    full UID (eg. "my_schema.my_reflections") or just a table name in the public
+    schema. Default is "public.reflections". The table and schema is created
+    if not present. 
+    
+    If this option is used together with the --reflections option, the
+    reflections are read from th  e given file and written back to the database.
+    If both options are missing, pg_graph will look for the default table and
+    load it if present
+
   -f,format=FORMAT:sql,exec,psql,yaml
     Input/output format. Can be one of 'sql', 'exec', 'psql', or 'yaml' (default)
 
@@ -50,7 +66,7 @@ SPEC = %(
   -k,kind=KIND:meta,type,data
     Output kind. Can be one of 'meta', 'type' (the default), or 'data'
 
-  -t,time
+  --time
     Emit timings for process
 
   load! -- DATABASE [FILE]
@@ -70,21 +86,38 @@ SPEC = %(
 #
 def load_type(timer, opts, database)
   tg = timer.group("initialization")
-  connection = tg.time("connect") { PgConn.new(database) if !opts.meta? && !opts.marshal? }
+  conn = tg.time("connect") { PgConn.new(database) if !opts.meta? && !opts.marshal? }
   meta = tg.time("meta") {
     if opts.meta?
       PgMeta.load_file(opts.meta)
     elsif opts.marshal?
       PgMeta.load_marshal(opts.marshal)
     else
-      PgMeta.new(connection)
+      PgMeta.new(conn)
     end
   }
   reflector = tg.time("reflector") { 
-    opts.reflections? ? PgGraph::Reflector.load_file(opts.reflections) : nil 
+    table, schema = opts.reflections_table&.split(".")&.reverse
+    schema ||= PgGraph::Reflector::REFLECTIONS_SCHEMA
+    table ||= PgGraph::Reflector::REFLECTIONS_TABLE
+
+    if opts.reflections?
+      r = PgGraph::Reflector.load_file(opts.reflections)
+      r.save_table(conn, schema, table) if opts.reflections_table?
+      r
+    else
+      if opts.reflections_table?
+        PgGraph::Reflector.load_table(conn, schema, table)
+      elsif conn.schema.exist_table?(schema, table)
+        PgGraph::Reflector.load_table(conn, schema, table)
+      else
+        nil
+      end
+    end
   }
-  type = timer.time("type") { PgGraph::Type.new(meta, reflector) }
-  [connection, type]
+      
+  type = timer.time("type") { PgGraph::Type.new(meta, reflector, ignore: opts.ignore) }
+  [conn, type]
 end
 
 opts, args = ShellOpts::ShellOpts.process(SPEC, ARGV)

data/lib/pg_graph/reflector.rb

@@ -26,12 +26,16 @@ module PgGraph
     # matches
     attr_reader :components
 
+    # True if this is a default reflection
+    attr_reader :default_reflection
+
     # +this+ and +that+ are template strings, nil, or false
-    def initialize(match, this, that, pluralize = false)
+    def initialize(match, this, that, pluralize = false, default_reflection = false)
       constrain match, Regexp, String
       constrain this, String, NilClass
       constrain that, String, FalseClass, NilClass
       constrain pluralize, TrueClass, FalseClass, NilClass
+      constrain default_reflection, TrueClass, FalseClass, NilClass
       @match = match.is_a?(Regexp) ? match.source : match
       if @match =~ /^\/(.*)\/$/
         re = $1
@@ -45,10 +49,11 @@ module PgGraph
       @this = this
       @that = that
       @pluralize = pluralize || pluralize.nil?
+      @default_reflection = default_reflection || false
     end
 
     def to_yaml
-      { match: match, this: this, that: that, pluralize: pluralize }
+      { match: match, this: this, that: that, pluralize: pluralize, default_reflection: default_reflection }
     end
 
     def ==(other)
@@ -66,11 +71,13 @@ module PgGraph
       }
     end
 
-  private
-    METHODS = %w(match this that pluralize).map(&:to_sym)
+    METHODS = %w(match this that pluralize default_reflection).map(&:to_sym)
   end
 
   class Reflector
+    REFLECTIONS_SCHEMA = "public"
+    REFLECTIONS_TABLE = "reflections"
+
     # Reflections ordered from most-specific to least-specific and newest to oldest
     def reflections()
       # assumes @reflection keys are created in descending order
@@ -140,6 +147,40 @@ module PgGraph
       load_yaml YAML.load(IO.read(file)), default_reflections: default_reflections
     end
 
+    def self.load_table(conn, schema = nil, table = nil, default_reflections: Reflector.default_reflections)
+      schema ||= REFLECTIONS_SCHEMA
+      table ||= REFLECTIONS_TABLE
+      if conn.schema.exist?(schema) && conn.schema.exist_table?(schema, table)
+        yaml = conn.structs(%(
+          select match, this, that, pluralize, false as "default_reflection"
+          from #{schema}.#{table}
+          order by ordinal
+        )).map(&:to_h)
+      else
+        yaml = {}
+      end
+      load_yaml yaml, default_reflections: default_reflections
+    end
+
+    def save_table(conn, schema = nil, table = nil)
+      schema ||= REFLECTIONS_SCHEMA
+      table ||= REFLECTIONS_TABLE
+      self.class.ensure_table(conn, schema, table)
+      values = reflections.select { |r| !r.default_reflection }.map.with_index { |reflection, i|
+        values = "(" + Reflection::METHODS.map { |m| 
+          v = reflection.send(m)
+          v.nil? ? "null" : "'#{v}'"
+        }.join(", ") + ", #{i})"
+      }.join(",\n")
+
+      conn.exec %(
+        insert into #{schema}.#{table} 
+            (match, this, that, pluralize, default_reflection, ordinal)
+        values
+          #{values}
+      )
+    end
+
     def self.default_reflections
       @default_reflections ||= begin
         initializers = [
@@ -153,7 +194,9 @@ module PgGraph
           {"match"=>"/(\\w+)_id/", "this"=>"$1", "that"=>"$$"},
           {"match"=>"/(\\w+)/", "this"=>"$1", "that"=>"$$"}, # Kind fields w/o explicit 'kind'
         ]
-        initializers.map { |initializer| Reflection.load_yaml(initializer) }
+        initializers.map { |initializer| 
+          Reflection.load_yaml initializer.merge(default_reflection: true) 
+        }
       end
     end
 
@@ -179,6 +222,29 @@ module PgGraph
         end
       }
     end
+
+    def self.create_table(conn, schema, table)
+      conn.exec %(
+        create table #{schema}.#{table} (
+          id integer generated by default as identity primary key,
+          match varchar not null,
+          this varchar,
+          that varchar not null,
+          pluralize boolean not null,
+          default_reflection boolean not null,
+          ordinal integer not null -- zero-based
+        )
+      )
+    end
+
+    def self.ensure_table(conn, schema, table)
+      conn.schema.create(schema) if !conn.schema.exist?(schema)
+      if conn.schema.exist_table?(schema, table)
+        conn.exec "truncate #{schema}.#{table}"
+      else
+        create_table(conn, schema, table)
+      end
+    end
   end
 end
 

data/lib/pg_graph/version.rb

@@ -1,3 +1,3 @@
 module PgGraph
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/pg_graph.rb

@@ -39,26 +39,29 @@ module PgGraph
     #   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
+    # The +reflections+ argument can be a Reflector object, an yaml array, a
+    # file name, a PgConn object, or nil. If +reflections+ is a PgConn object,
+    # the +schema+ argument should be set to the schema containing the
+    # 'reflections' table. 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: [])
+    def self.new(arg, reflections = nil, schema = nil, ignore: [])
       constrain arg, PgMeta, PgConn
-      constrain reflect, Reflector, Array, String, NilClass
+      constrain reflections, Reflector, Array, String, PgConn, 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)
+          case reflections
+            when Reflector; reflections
+            when Array; Reflector.load_yaml(reflections)
+            when String; Reflector.load_file(reflections)
+            when PgConn; Reflector.load_table(reflections, schema)
             when NilClass; Reflector.new
           end
       Database.new(meta.name, reflector).read(meta, ignore: ignore)

data/lib/type/type.rb

@@ -173,7 +173,7 @@ module PgGraph::Type
     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}"
+      PgGraph.inflector.plural?(name) or raise Error, "Table names should be plural: #{schema.name}.#{name}"
       super(schema, name)
       @path = "#{schema.name}.#{name}"
       @mm_table = mm_table || nm_table

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-24 00:00:00.000000000 Z
+date: 2022-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: boolean