pg_graph 0.1.2 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 108d2c8460c15baf7814fc56fbf5f3dc2cd3ebf8e0991cda6590d73aef31d103
-  data.tar.gz: '0931cbd88556516ce7a210312a23227efae4c6003ec4e2c83b265f08762fa6b9'
+  metadata.gz: 9bbbf1239ad74e0ccf7709ce4bd1ccf77d6e319c390836aa749000a0ce3360ef
+  data.tar.gz: 4c433919870bb792e153105cf23ea4f9c969cb8c1251da5671793c5941ebc084
 SHA512:
-  metadata.gz: '00919e561ec71e0ae20a7d3e425b46824b1b67a5ae4812bd6e10162f6e53ce054cb94a05c5e8f062fad7a08d97aa9e3ccd76974679cad6c45abef56857372c69'
-  data.tar.gz: 97747263d0d3583b223c7bb2727b8403642f41d8e0c9ebdcf3f7aa0cbc013ad0528e91f0a7c8852636a083581141ca6179f5a75e6280b1266c7365dbc85b4d40
+  metadata.gz: 26f90ddc3c0302bb0584013ab7abeb2236d3d663541a63adc51f9b7d05baa063477efdac183c52ae998fbe14b91da9ebda0f659b8112c35e2fba125254ebbf0b
+  data.tar.gz: a1bd282fd15b758251bab23adf20585b05f2ec58e1ffa39dc91350430bf06f5e8b1c7dda061015376bc42441a9137c52d0d9b30e171b3c2d0a17235c8d1efb9e

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,24 +86,41 @@ 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, :version => PgGraph::VERSION)
+opts, args = ShellOpts::ShellOpts.process(SPEC, ARGV)
 
 timing = opts.time?
 timer = Timer::Timer.new

data/lib/pg_graph/inflector.rb

@@ -86,7 +86,7 @@ module PgGraph
       case name
         when "character varying", "varchar", "text", "uuid"; String
         when "smallint", "integer", "int4", "int2"; Integer
-        when "double precision", "real"; Float
+        when "double precision", "real", "float8"; Float
         when "numeric", "decimal"; BigDecimal
         when "bool", "boolean"; Boolean
         when "json"; Hash

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.2"
+  VERSION = "0.1.5"
 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.2
+  version: 0.1.5
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-24 00:00:00.000000000 Z
+date: 2022-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: boolean