pg_meta 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58339598c12ed8e286ecdd941ab1497947e5de3001c1dd1434888c05056551ba
-  data.tar.gz: e4b3bcf44fe2286760fd83841f8e42d5ca98a09cf08a8f3406f78a1d76c25671
+  metadata.gz: 11de6eb1003d273e1ab21fa858a61db0a92c38d033b9e21b731d6e58e76b32dc
+  data.tar.gz: d5104b86eb79c567d20d2d352d3c8a05c9abe6605205c91c91aca5326ee2e541
 SHA512:
-  metadata.gz: a6918852294bd4207e93dc1730a64e6b4036db0807c2158de808da264de7200a34e08c8f40b7b59a07fbc454e098fdd9a9fbc436a2dd8bf5972e51a8aa7d8beb
-  data.tar.gz: 7c7c1166566190064ef0f45c24c2eee1b5a23fb89272963951203e915fd0a23cc8be5fc37c7499920684d754e0ee543e897bd20961667b31ab0536c9b651ce3a
+  metadata.gz: e3d7d7e1651f022d7965c193eb8ce91ea1ab529708299aeb5994ab6ede3119e8fd2f2bbac1b251b8c8a6a71ca44899023faa505470c29f94b64c1cb50b23bb5d
+  data.tar.gz: 8c6df9dc133a01171cf7e53954f63f948a0bb4a1b9d1e0c3e21f2195241932b4e734a0a0431315bf7ebaf4ec8085484e59533acde1a94be490576cd67882c700

data/lib/pg_meta/load_conn.rb

@@ -6,9 +6,9 @@ module PgMeta
     # Load the database from the given PgConn::Connection object. This method is a
     # transaction wrapper around #do_load_conn
     def self.load_conn(pg_conn, exclude_schemas: [])
-      pg_conn.pg_connection.transaction { |conn| 
+      pg_conn.pg_connection.transaction { |conn|
         conn.exec "set transaction isolation level serializable read only deferrable"
-        do_load_from_connection(conn, exclude_schemas: exclude_schemas) 
+        do_load_from_connection(conn, exclude_schemas: exclude_schemas)
       }
     end
 
@@ -37,7 +37,7 @@ module PgMeta
       db = Database.new(conn.db, owner)
 
       # Schema excludes
-      exclude_sql = 
+      exclude_sql =
 
       # Build schemas
       conn.exec(%(
@@ -65,7 +65,7 @@ module PgMeta
         and     c.relkind in ('r', 'v', 'm')
       )).each { |row|
         schema = db.schemas[row[:schema]]
-        klass = 
+        klass =
             case row[:relkind]
               when 'r'; Table
               when 'v'; View
@@ -95,9 +95,9 @@ module PgMeta
           join    pg_constraint c on c.oid = d.objid
           join    chain ch on ch.that = c.conrelid
         )
-        select  n1.nspname as this_schema, 
-                t1.relname as this_table, 
-                n2.nspname as that_schema, 
+        select  n1.nspname as this_schema,
+                t1.relname as this_table,
+                n2.nspname as that_schema,
                 t2.relname as that_table
         from chain c
         join pg_class t1 on t1.oid = c.this
@@ -152,12 +152,12 @@ module PgMeta
                 coalesce(i.is_generated, 'NO') = 'ALWAYS' as "generated?",
                 coalesce(i.is_nullable, 'NO') = 'YES' as "nullable?",
                 coalesce(i.is_updatable, 'NO') = 'YES' as "updatable?"
-        from    pg_namespace n 
+        from    pg_namespace n
         join    pg_class c on c.relnamespace = n.oid
         join    pg_attribute a on a.attrelid = c.oid
         join    pg_type t on t.oid = a.atttypid
         left join pg_type t2 on t2.oid = t.typelem
-        left join information_schema.columns i on 
+        left join information_schema.columns i on
                     i.table_schema = n.nspname
                 and i.table_name = c.relname
                 and i.column_name = a.attname
@@ -232,7 +232,7 @@ module PgMeta
                 "table",
                 "index",
                 "unique"
-        order by 
+        order by
                 "schema",
                 "table",
                 "index"
@@ -252,42 +252,111 @@ module PgMeta
       # the referenced table and that yields a row for each column in the unique
       # key (TODO: Can this be omitted?)
       #
+#     conn.exec(%(
+#       select  rc.constraint_schema::text as schema,
+#               rc.constraint_name::text as name,
+#               cu_refing.table_schema::text as "referencing_schema",
+#               cu_refing.table_name::text as "referencing_table",
+#               (
+#                 select  array_agg(column_name::text order by ordinal_position)
+#                 from    information_schema.key_column_usage kcu
+#                 where   kcu.constraint_schema = rc.constraint_schema
+#                 and     kcu.constraint_name = rc.constraint_name
+#               ) as "referencing_columns",
+#               cu_refed.table_schema::text as referenced_schema,
+#               cu_refed.table_name::text as referenced_table,
+#               cu_refed.constraint_name::text as referenced_constraint
+#       from    information_schema.referential_constraints rc
+#       join    information_schema.key_column_usage cu_refing
+#               on  cu_refing.constraint_schema = rc.constraint_schema
+#                   and cu_refing.constraint_name = rc.constraint_name
+#       join    information_schema.key_column_usage cu_refed
+#               on  cu_refed.constraint_schema = rc.unique_constraint_schema
+#                   and cu_refed.constraint_name = rc.unique_constraint_name
+#       where   #{exclude_sql("cu_refing.table_schema", exclude_schemas)}
+#       group by
+#               rc.constraint_schema,
+#               rc.constraint_name,
+#               cu_refing.table_schema,
+#               cu_refing.table_name,
+#               cu_refed.table_schema,
+#               cu_refed.table_name,
+#               cu_refed.constraint_name
+#     )).each { |row|
+#       schema = db.schemas[row[:schema]]
+#       name = row[:name]
+#       referencing_table = schema.tables[row[:referencing_table]]
+#       referencing_columns = lookup_columns(referencing_table, row[:referencing_columns])
+#       referenced_constraint =
+#           db.schemas[row[:referenced_schema]] \
+#           .tables[row[:referenced_table]] \
+#           .constraints[row[:referenced_constraint]]
+#       ref = ReferentialConstraint.new(referencing_table, name, referencing_columns, referenced_constraint)
+#       ref.referenced_table.send(:add_depending_table, referencing_table)
+#     }
+#     p conn.duration
       conn.exec(%(
-        select  rc.constraint_schema::text as schema,
-                rc.constraint_name::text as name,
-                cu_refing.table_schema::text as "referencing_schema",
-                cu_refing.table_name::text as "referencing_table",
-                (
-                  select  array_agg(column_name::text order by ordinal_position)
-                  from    information_schema.key_column_usage kcu
-                  where   kcu.constraint_schema = rc.constraint_schema
-                  and     kcu.constraint_name = rc.constraint_name
-                ) as "referencing_columns",
-                cu_refed.table_schema::text as referenced_schema,
-                cu_refed.table_name::text as referenced_table,
-                cu_refed.constraint_name::text as referenced_constraint
-        from    information_schema.referential_constraints rc
-        join    information_schema.key_column_usage cu_refing 
-                on  cu_refing.constraint_schema = rc.constraint_schema
-                    and cu_refing.constraint_name = rc.constraint_name
-        join    information_schema.key_column_usage cu_refed 
-                on  cu_refed.constraint_schema = rc.unique_constraint_schema
-                    and cu_refed.constraint_name = rc.unique_constraint_name
-        where   #{exclude_sql("cu_refing.table_schema", exclude_schemas)}
+        with
+          constraints as (
+            select
+              c.*,
+              num,
+              fnum
+            from
+              pg_constraint as c,
+              unnest(c.conkey) with ordinality as ff(num, index), -- from field
+              unnest(c.confkey) with ordinality as tf(fnum, index) -- to field
+            where
+              c.contype = 'f'
+              and ff.index = tf.index
+          ),
+          name_constraints as (
+            select
+              c.connamespace::regnamespace::text as "schema",
+              c.conname::text as "name",
+              cf.relnamespace::regnamespace::text as "referencing_schema",
+              cf.relname::text as "referencing_table",
+              af.attname::text as "referencing_column",
+              ct.relnamespace::regnamespace::text as "referenced_schema",
+              ct.relname::text as "referenced_table",
+              at.attname::text as "referenced_column",
+              idx.relname::text as "referenced_constraint"
+            from
+              constraints c
+              join pg_attribute as af on af.attnum = c.num and af.attrelid = c.conrelid -- attribute-from
+              join pg_attribute as at on at.attnum = c.fnum and at.attrelid = c.confrelid
+              join pg_class as cf on cf.oid = c.conrelid
+              join pg_class as ct on ct.oid = c.confrelid
+              join pg_class as idx on idx.oid = c.conindid
+            where
+              #{exclude_sql("cf.relnamespace::regnamespace::text", exclude_schemas)}
+          )
+        select
+          "schema",
+          name,
+          referencing_schema,
+          referencing_table,
+          array_agg(referencing_column) as "referencing_columns",
+          referenced_schema,
+          referenced_table,
+    --    array_agg(referenced_columnn) as "referenced_columns",
+          referenced_constraint
+        from
+          name_constraints
         group by
-                rc.constraint_schema,
-                rc.constraint_name,
-                cu_refing.table_schema,
-                cu_refing.table_name,
-                cu_refed.table_schema,
-                cu_refed.table_name,
-                cu_refed.constraint_name
+          "schema",
+          name,
+          referencing_schema,
+          referencing_table,
+          referenced_schema,
+          referenced_table,
+          referenced_constraint
       )).each { |row|
         schema = db.schemas[row[:schema]]
         name = row[:name]
         referencing_table = schema.tables[row[:referencing_table]]
         referencing_columns = lookup_columns(referencing_table, row[:referencing_columns])
-        referenced_constraint = 
+        referenced_constraint =
             db.schemas[row[:referenced_schema]] \
             .tables[row[:referenced_table]] \
             .constraints[row[:referenced_constraint]]
@@ -299,16 +368,16 @@ module PgMeta
       conn.exec(%(
         select  s.nspname::text as "schema",
                 pg_get_userbyid(p.proowner)::text as "owner",
-                format('%I(%s)', p.proname, oidvectortypes(p.proargtypes)) 
-                  || ': ' 
+                format('%I(%s)', p.proname, oidvectortypes(p.proargtypes))
+                  || ': '
                   || format_type(p.prorettype, null) as "name",
-                case format_type(p.prorettype, null) 
-                  when 'void' then 'procedure' 
-                  else 'function' 
+                case format_type(p.prorettype, null)
+                  when 'void' then 'procedure'
+                  else 'function'
                 end as "kind",
-                case 
-                  when prosecdef then 'definer' 
-                  else 'invoker' 
+                case
+                  when prosecdef then 'definer'
+                  else 'invoker'
                 end as "security"
         from    pg_proc p
         join    pg_namespace s on (p.pronamespace = s.oid)
@@ -321,12 +390,12 @@ module PgMeta
 
       # Build user-defined triggers
       conn.exec(%(
-        select  n.nspname::text as "schema", 
-                c.relname::text as "table", 
+        select  n.nspname::text as "schema",
+                c.relname::text as "table",
                 t.tgname::text as "name",
                 fn.nspname::text as "function_schema",
-                format('%I(%s)', p.proname::text, oidvectortypes(p.proargtypes)) 
-                  || ': ' 
+                format('%I(%s)', p.proname::text, oidvectortypes(p.proargtypes))
+                  || ': '
                   || format_type(p.prorettype, null) as "function_name",
                 case when (tgtype::int::bit(7) & b'0000001')::int = 0 then 'stmt' else 'row' end as "level",
                 coalesce(
@@ -334,7 +403,7 @@ module PgMeta
                   case when (tgtype::int::bit(7) & b'0000010')::int = 0 then 'after' else null end,
                   case when (tgtype::int::bit(7) & b'1000000')::int = 0 then null else 'instead' end,
                   ''
-                )::text as "timing", 
+                )::text as "timing",
                   (case when (tgtype::int::bit(7) & b'0000100')::int = 0 then '' else ' insert' end) ||
                   (case when (tgtype::int::bit(7) & b'0001000')::int = 0 then '' else ' delete' end) ||
                   (case when (tgtype::int::bit(7) & b'0010000')::int = 0 then '' else ' update' end) ||

data/lib/pg_meta/meta.rb

@@ -46,7 +46,7 @@ module PgMeta
       h = {}
       Array(attrs).flatten.each { |attr|
         value = self.send(attr)
-        h[attr] = 
+        h[attr] =
             case value
               when Array
                 if value.first.is_a?(Symbol)
@@ -281,7 +281,7 @@ module PgMeta
   class View < Table
     # List of views and tables used directly in the definition of this view
     attr_reader :defining_relations
-    
+
     # List of tables used directly or indirectly in the definition of this view
     attr_reader :defining_tables
 
@@ -293,9 +293,9 @@ module PgMeta
       @defining_tables = []
     end
 
-    def to_h() 
+    def to_h()
       h = super
-      h[:defining_relations] = defining_relations.map(&:uid) 
+      h[:defining_relations] = defining_relations.map(&:uid)
       h[:defining_tables] = defining_tables.map(&:uid)
       h
     end
@@ -374,9 +374,9 @@ module PgMeta
 
     # True if column is a single-column reference to another record and is of
     # type varchar or text
-    def kind?() 
-      @kind ||= 
-          references.size == 1 && 
+    def kind?()
+      @kind ||=
+          references.size == 1 &&
           references.first.referencing_columns.size == 1 &&
           !references.first.referenced_columns.first.primary_key?
     end
@@ -391,12 +391,12 @@ module PgMeta
     end
 
     def initialize(
-        table, name, ordinal, type, element_type, dimensions, default, 
+        table, name, ordinal, type, element_type, dimensions, default,
         is_identity, is_generated, is_nullable, is_updatable)
       super(table, name)
-      @type, @element_type, @dimensions, @ordinal, @default, @is_identity, 
+      @type, @element_type, @dimensions, @ordinal, @default, @is_identity,
           @is_generated, @is_nullable, @is_updatable =
-            type, element_type, dimensions, ordinal, default, is_identity, 
+            type, element_type, dimensions, ordinal, default, is_identity,
             is_generated, is_nullable, is_updatable
       table.columns[name] = self
     end
@@ -541,7 +541,7 @@ module PgMeta
     def initialize(schema, name, owner, security)
       super(schema, name)
       @owner = owner
-      @security = security.to_sym 
+      @security = security.to_sym
       if function?
         schema.functions[name] = self
       else
@@ -569,7 +569,7 @@ module PgMeta
     # When trigger is fired (:before, :after, or :instead)
     attr_reader :timing
 
-    # Array of events (:insert, :update, :delete, or :truncate) causing the trigger to fire 
+    # Array of events (:insert, :update, :delete, or :truncate) causing the trigger to fire
     attr_reader :events
 
     # Note that trigger names have a '()' suffixed. This avoid namespace

data/lib/pg_meta/version.rb

@@ -1,3 +1,3 @@
 module PgMeta
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_meta
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-10 00:00:00.000000000 Z
+date: 2024-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: indented_io