meta_db 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b95c7477345548208fedec3a8b23fec8f99976679d2a7cda7a862da2a55e065
-  data.tar.gz: b1fd9306b6a6fa4ea129e2774b00a9cba4498fdcdb0f7bc9292009c8e8a8318a
+  metadata.gz: a51836f5ebbe95799043394f44b151d2e722eecaae0f5be6a993c3a35eb353cc
+  data.tar.gz: 0f81dcdfdec3f3033fa7726fae89f734da23e783ce473b737b2e2b3150c67c1b
 SHA512:
-  metadata.gz: 69e015dab2b969d70e665b07963d860ab8d0791dc24d3e9c13ab1e424a6e8c1194cb2f58b2c222185f6ee7cc45ff36a3bedf5422a48196dc9257b0972c9cafa5
-  data.tar.gz: 69b2dd7664171a1be23993da78dde65720d2bee94e126fd77839d5f921fc432697d439e2a88aea00d0ce555489adc1949ad1dfb02bb9815c0a8c97357f98bad5
+  metadata.gz: b916d8bb0995189452ba838199bd8c887b56aba3d5d63399fcd6fb4a270ed8fbe506127edc98a1c7bf82c331d57e5ded69aa0c69eaaf8e93ab88838b5bd21f47
+  data.tar.gz: ccafad6e13a9d0eab5d130935f94d24a294d7cd85462fd871e3ef02fb901a5d60ecbb71feb852e9d82ae99237c79687ac47766525341ae48d584d8f00cb18d37

data/.ruby-version

@@ -1 +1 @@
-ruby-2.6.6
+ruby-2.7.0

data/lib/meta_db.rb

@@ -51,12 +51,12 @@ private
       where   d.datname = '#{conn.database}'
     )
     r.size == 1 or raise "Internal error"
-    db = MetaDb::Database.new(conn.database, r.each_array.first)
+    db = MetaDb::Database.new(conn.database, r.value)
 
     # Build schemas
     conn.select(%(
-      select  schema_name::varchar as name,
-              schema_owner::varchar as owner
+      select  schema_name::text as name,
+              schema_owner::text as owner
       from    information_schema.schemata
       where   schema_name !~ '^pg_' AND schema_name <> 'information_schema' 
     )).each_hash { |row|
@@ -66,45 +66,47 @@ private
 
     # Build tables
     conn.select(%(
-      select  table_schema::varchar as schema,
-              table_name::varchar as name,
-              table_type::varchar as type,
+      select  table_schema::text as schema,
+              table_name::text as name,
+              table_type::text as type,
               is_insertable_into = 'YES' as "insertable?",
               is_typed = 'YES' as "typed?"
       from    information_schema.tables
       where   table_schema !~ '^pg_' AND table_schema <> 'information_schema'
     )).each_hash { |row|
-      row[:schema] = db.dot row[:schema]
+      row[:schema] = db.schemas[row[:schema]]
       klass = (row[:type] == 'VIEW' ? MetaDb::View : MetaDb::Table)
       klass.init(row)
     }
 
     # Build columns
     conn.select(%(
-      select  table_schema::varchar || '.' || table_name as table,
+      select  table_schema::text as schema,
+              table_name::text as table,
+              column_name::text as name,
               ordinal_position as ordinal,
-              column_name::varchar as name,
-              data_type::varchar as type,
+              data_type::text as type,
               column_default as default,
               is_identity = 'YES' as "identity?",
-              is_generated = 'YES' as "generated?",
+              is_generated = 'ALWAYS' as "generated?",
               is_nullable = 'YES' as "nullable?",
               is_updatable = 'YES' as "updatable?"
       from    information_schema.columns
       where   table_schema !~ '^pg_' AND table_schema <> 'information_schema'
     )).each_hash { |row|
-      row[:table] = db.dot row[:table]
+      row[:table] = db.schemas[row[:schema]].tables[row[:table]]
       MetaDb::Column.init(row)
     }
 
     # Build simple constraints
     conn.select(%(
-      select  c.constraint_type::varchar,
-              c.table_schema || '.' || c.table_name as table,
-              c.constraint_name::varchar as name,
+      select  c.table_schema::text as schema,
+              c.table_name::text as table,
+              c.constraint_type::text,
+              c.constraint_name::text as name,
               cc.check_clause as expression,
               (
-                select  array_agg(column_name::varchar)
+                select  array_agg(column_name::text)
                 from    information_schema.constraint_column_usage ccu
                 where   ccu.table_schema = c.table_schema
                 and     ccu.table_name = c.table_name
@@ -112,13 +114,13 @@ private
                 and     ccu.constraint_name = c.constraint_name
               ) as columns
       from    information_schema.table_constraints c
-        left join information_schema.check_constraints cc
-          on cc.constraint_schema = c.table_schema and
-             cc.constraint_name = c.constraint_name
+      left join information_schema.check_constraints cc
+                on  cc.constraint_schema = c.table_schema and
+                    cc.constraint_name = c.constraint_name
       where   c.table_schema !~ '^pg_' AND c.table_schema <> 'information_schema'
       and     c.constraint_type in ('PRIMARY KEY', 'UNIQUE', 'CHECK')
     )).each_hash { |row|
-      row[:table] = db.dot row[:table]
+      row[:table] = db.schemas[row[:schema]].tables[row[:table]]
       row[:columns] = lookup_columns(row[:table], row[:columns] || [])
       case row[:constraint_type]
         when "PRIMARY KEY"; MetaDb::PrimaryKeyConstraint.init(row)
@@ -139,22 +141,24 @@ private
     # key (TODO: Can this be omitted?)
     #
     conn.select(%(
-      select  rc.constraint_schema::varchar as schema,
-              rc.constraint_name::varchar as name,
-              cu_refing.table_schema || '.' || cu_refing.table_name as "referencing_table",
+      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::varchar order by ordinal_position)
+                select  array_agg(column_name::text order by ordinal_position)
                 from    information_schema.key_column_usage kcu
                 where   kcu.constraint_name = rc.constraint_name
               ) as "referencing_columns",
-              cu_refed.table_schema || '.' || cu_refed.table_name || '.' || cu_refed.constraint_name 
-                  as "referenced_constraint"
+              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
+      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
+      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   cu_refing.table_schema !~ '^pg_' AND cu_refing.table_schema <> 'information_schema'
       group by
@@ -166,17 +170,81 @@ private
               cu_refed.table_name,
               cu_refed.constraint_name
     )).each_hash { |row|
-      row[:schema] = db.dot row[:schema]
-      row[:referencing_table] = db.dot row[:referencing_table]
+      row[:schema] = db.schemas[row[:schema]]
+      row[:referencing_table] = row[:schema].tables[row[:referencing_table]]
       row[:referencing_columns] = lookup_columns(row[:referencing_table], row[:referencing_columns])
-      row[:referenced_constraint] = db.dot row[:referenced_constraint]
+      row[:referenced_constraint] = 
+          db.schemas[row[:referenced_schema]] \
+          .tables[row[:referenced_table]] \
+          .constraints[row[:referenced_constraint]]
       MetaDb::ReferentialConstraint.init(row)
     }
+
+    # Build functions and procedures
+    conn.select(%(
+      select  s.nspname::text as "schema",
+              pg_get_userbyid(p.proowner)::text as "owner",
+              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' 
+              end as "kind",
+              case 
+                when prosecdef then 'definer' 
+                else 'invoker' 
+              end as "security"
+      from    pg_proc p
+      join    pg_namespace s on (p.pronamespace = s.oid)
+      where   s.nspname !~ '^pg_' AND s.nspname <> 'information_schema'
+    )).each_hash { |row|
+      row[:schema] = db.schemas[row[:schema]]
+      klass = (row[:kind] == 'function' ? MetaDb::Function : MetaDb::Procedure)
+      klass.init(row)
+    }
+
+    # Build user-defined triggers
+    conn.select(%(
+      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_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(
+                case when (tgtype::int::bit(7) & b'0000010')::int = 0 then null else 'before' end,
+                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", 
+                (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) ||
+                (case when (tgtype::int::bit(7) & b'0100000')::int = 0 then '' else ' truncate' end)
+              as "events"
+      from    pg_trigger t
+      join    pg_proc p on t.tgfoid = p.oid
+      join    pg_class c on c.oid = t.tgrelid
+      join    pg_namespace n on n.oid = c.relnamespace
+      join    pg_namespace fn on fn.oid = p.pronamespace
+      where   not t.tgisinternal
+    )).each_hash { |row|
+      schema = db.schemas[row[:schema]]
+      row[:table] = schema.tables[row[:table]]
+      function_schema = db.schemas[row[:function_schema]]
+      row[:function] = function_schema.functions[row[:function_name]]
+      MetaDb::Trigger.init(row)
+    }
+
+    # Return database object
     db
   end
 
   def self.lookup_columns(table, column_names)
-    column_names.map { |n| table.children[n] }
+    column_names.map { |n| table.columns[n] }
   end
 end
 

data/lib/meta_db/connection.rb

@@ -1,5 +1,8 @@
 
 module MetaDb
+
+  # FIXME Why on earth did I do this?
+  #
   class Connection
     # In derived classes, no initialization may take place after the call to
     # super because otherwise #initialize would call the user-supplied block
@@ -43,6 +46,20 @@ module MetaDb
   class Result
     def initialize(result) @result = result end
     def size() raise end
+
+    # Returns the value of the first field of the first record in the result
+    # set
+    def value() each_tuple.first.first end
+
+    # Returns a hash of the first record in the result set
+    def record() each_hash.first end
+
+    # Returns an array of the first record in the result set
+    def tuple() each_tupe.first end
+
+    def each_record() each_hash end
+    def each_tuple() each_array end
+
     def each_hash() raise end
     def each_array() raise end
     def to_a() each_array end

data/lib/meta_db/db_object.rb

@@ -3,9 +3,8 @@ require 'meta_db/dump.rb'
 
 module MetaDb
   class DbObject
-    # Used to multi-assign values and for dump
-    #
-    # TODO: rename db_attr or 'column', and create read/writer methods
+    # ::attrs defines the set of members of an object. It is used in
+    # initialization (in #init) and in #dump
     def self.attrs(*attrs)
       attrs = Array(attrs)
       if attrs.empty?
@@ -15,102 +14,38 @@ module MetaDb
       end
     end
 
+    # Initialize a DbObject. row is a hash with symbolic keys (typically the
+    # result of a database query). Values of keys included in ::attrs are
+    # extracted from the row and passed to the #initialize method of the object
+    # in the same order as in ::attrs
     def self.init(row)
       h = []
-      self.attrs.each { |a| h << row[a] if row.key?(a) }
+      (@attrs ||= []).each { |a| h << row[a] if row.key?(a) }
       self.new(*h)
     end
 
-    attrs :parent, :name, :children
-
-    # Name of object. Unique within contianing object. Not nil
-    attr_reader :name 
-
-    # Parent DbObject. Non-nil except for the top-level MetaDb::Database object
-    attr_reader :parent
-
-    # Hash from name to contained objects
-    attr_reader :children
-
-    def initialize(parent, name)
-      @name, @parent = name, parent
-      @children = {}
-      parent&.send(:attach, self)
-    end
-
-    # Unique dot-separated list of names leading from the top-level MetaDb::Database object to 
-    # self. Omits the first path-element if strip is true
-    def path(strip: false)
-      r = []
-      node = self
-      while node
-        r << node.name
-        node = node.parent
-      end
-      r.pop if strip
-      r.reverse.compact.join(".")
-    end
-
-    # Return child object with the given name
-    def [](name) @children[name] end
-
-    # Recursively lookup object by dot-separated list of names. If strip is true, the first element
-    # will be stripped from the path
-    def dot(path, strip: false)
-      elems = path.split(".")
-      elems.shift if strip
-      elems.inject(self) { |a,e| a[e] } or raise "Can't lookup '#{path}' in #{self.path}"
-    end
-
-    # Compare two objects by identity
-    def <=>(r) path <=> r.path end
-
-    # Mostly for debug
-    def inspect
-      string = StringIO.new
-      stdout = $stdout
-      begin
-        $stdout = string
-        dump
-      ensure
-        $stdout = stdout
-      end
-      string.string
-    end
-
-  protected
-    def constrain_children(klass)
-      children.values.select { |v| v.is_a?(klass) }
-    end
+    # Unique name within context. This is usually what we understand as the
+    # name of an object but functions have the full signature as "name"
+    attr_reader :name
 
-  private
-    def attach(child)
-      !@children.key?(child.name) or raise "Duplicate child key: #{child.name.inspect}"
-      child.instance_variable_set(:@parent, self)
-      @children[child.name] = child
-    end
-
-    def detach(child)
-      @children.key?(child.name) or raise "Non-existing child key: #{child.name.inspect}"
-      child.instance_variable_set(:@parent, nil)
-      @children.delete(child.name)
+    def initialize(name)
+      @name = name
     end
   end
 
   class Database < DbObject
     attrs :name, :owner, :schemas
 
-    # List of schemas
-    def schemas()
-      @schemas ||= children.values
-    end
-
     # Owner of the database
     attr_reader :owner
 
+    # Hash of schemas
+    attr_reader :schemas
+
     def initialize(name, owner)
-      super(nil, name)
+      super(name)
       @owner = owner
+      @schemas = {}
     end
   end
 
@@ -118,26 +53,31 @@ module MetaDb
     attrs :database, :name, :owner, :tables, :views, :functions, :procedures
 
     # Database of the schema
-    alias_method :database, :parent
+    attr_reader :database
 
     # Owner of the schema
     attr_reader :owner
 
-    # List of tables (and views)
-    def tables() @tables ||= constrain_children(MetaDb::Table) end
+    # Hash of tables (and views)
+    attr_reader :tables
 
-    # List of views
-    def views() @views ||= constrain_children(MetaDb::View) end
+    # Hash of views
+    def views() @views ||= @tables.select { |_, table| table.view? } end
 
-    # List of functions
-    def functions() @functions ||= constrain_children(MetaDb::Function) end
+    # Hash of functions
+    attr_reader :functions
 
-    # List of procedures
-    def procedures() @procedures ||= constrain_children(MetaDb::Procedure) end
+    # Hash of procedures
+    attr_reader :procedures
 
     def initialize(database, name, owner)
-      super(database, name)
+      super(name)
+      @database = database
       @owner = owner
+      @tables = {}
+      @functions = {}
+      @procedures = {}
+      @database.schemas[name] = self
     end
   end
 
@@ -146,8 +86,8 @@ module MetaDb
       :schema, :name, :type, :table?, :view?, :insertable?, :typed?, :columns,
       :primary_key_columns, :constraints, :referential_constraints, :triggers
 
-    # Schema of the table. Redefines #parent
-    alias_method :schema, :parent
+    # Schema of the table
+    attr_reader :schema
 
     # Type of table. Either 'BASE TABLE' or 'VIEW'
     attr_reader :type
@@ -164,8 +104,8 @@ module MetaDb
     # True if the table/view is typed
     def typed?() @is_typed end
 
-    # List of columns. Columns are sorted by ordinal
-    def columns() @columns ||= constrain_children(MetaDb::Column).sort end
+    # Hash of columns
+    attr_reader :columns
 
     # The primary key column. nil if the table has multiple primary key columns
     def primary_key_column
@@ -182,39 +122,56 @@ module MetaDb
     # Note: Assigned by PrimaryKeyConstraint#initialize
     attr_reader :primary_key_columns
 
-    # List of constraints
-    def constraints() 
-      @constraints ||= constrain_children(MetaDb::Constraint) 
-    end
+    # Hash of all constraints
+    attr_reader :constraints
 
-    # List of referential constraints
-    def referential_constraints() 
-      @referential_constraints ||= constrain_children(MetaDb::ReferentialConstraint) 
-    end
+    # List of primary key constraints (there is only one element)
+    attr_reader :primary_key_constraints
 
-    # List of triggers
-    def triggers() @triggers ||= constrain_children(MetaDb::Trigger) end
+    # Hash of unique constraints
+    attr_reader :unique_constraints
+
+    # Hash of check constraints
+    attr_reader :check_constraints
+
+    # Hash of referential constraints
+    attr_reader :referential_constraints
+
+    # Hash of triggers
+    attr_reader :triggers
 
     def initialize(schema, name, type, is_insertable, is_typed)
-      super(schema, name)
+      super(name)
+      @schema = schema
       @type, @is_insertable, @is_typed = type, is_insertable, is_typed
+      @columns = {}
       @primary_key_column = :undefined
       @primary_key_columns = []
+      @constraints = {}
+      @primary_key_constraints = []
+      @unique_constraints = {}
+      @check_constraints = {}
+      @referential_constraints = {}
+      @triggers = {}
+      @schema.tables[name] = self
     end
-
   end
 
   class View < Table
+    attrs \
+      :schema, :name, :type, :table?, :view?, :insertable?, :typed?, :columns,
+      :primary_key_columns, :constraints, :referential_constraints, :triggers
+
     def table?() false end
   end
 
   class Column < DbObject
     attrs \
-      :table, :ordinal, :name, :type, :default, :identity?, :generated?,
+      :table, :name, :ordinal, :type, :default, :identity?, :generated?,
       :nullable?, :updatable?, :primary_key?
 
     # Table of the column
-    alias_method :table, :parent
+    attr_reader :table
 
     # Ordinal number of the column
     attr_reader :ordinal
@@ -237,17 +194,42 @@ module MetaDb
     # True if column is updatable
     def updatable?() @is_updatable end
 
-    # True if column is the single primary key of the table. Always false for tables
+    # True if column is unique (not that this information is not stored in the
+    # Column but in a table constraint)
+    def unique?()
+      table.unique_constraints.values.any? { |constraint| constraint.columns == [self] }
+    end
+
+    # True if column is the single primary key of the table and false otherwise. Always nil for tables
     # with multiple primary keys
-    def primary_key?() table.table? && self == table.primary_key_column end
+    def primary_key?()
+      return nil if table.primary_key_columns.size != 1
+      table.table? && self == table.primary_key_column 
+    end
 
     # True is column is (part of) the primary key of the table
     def primary_key_column?() table.table? && table.primary_key_columns.include?(self) end
 
-    def initialize(table, ordinal, name, type, default, is_identity, is_generated, is_nullable, is_updatable)
-      super(table, name)
+    # True if column is referencing another record
+    def reference?()
+      @reference ||= !references.empty?
+    end
+
+    # List of referential constraints that involve this column
+    def references
+      @references ||= begin
+        table.referential_constraints.values.select { |constraint|
+          constraint.referencing_columns.include?(self)
+        }
+      end
+    end
+
+    def initialize(table, name, ordinal, type, default, is_identity, is_generated, is_nullable, is_updatable)
+      super(name)
+      @table = table
       @type, @ordinal, @default, @is_identity, @is_generated, @is_nullable, @is_updatable =
           type, ordinal, default, is_identity, is_generated, is_nullable, is_updatable
+      @table.columns[name] = self
     end
 
     # Compare columns by table and ordinal
@@ -264,7 +246,13 @@ module MetaDb
     attrs :table, :name, :columns
 
     # Table of the constraint
-    alias_method :table, :parent
+    attr_reader :table
+
+    # Constraint column. Raise an error if the constraint is multi-column
+    def column
+      columns.size == 1 or raise "Multicolumn constraint"
+      columns.first
+    end
 
     # List of columns in the constraint. Empty for CheckConstraint objects
     attr_reader :columns
@@ -273,22 +261,28 @@ module MetaDb
     def kind() CONSTRAINT_KINDS[self.class] end
 
     def initialize(table, name, columns)
-      super(table, name)
+      super(name)
+      @table = table
       @columns = columns
+      @table.constraints[name] = self
     end
   end
 
-  class PrimaryKeyConstraint < Constraint
+   class PrimaryKeyConstraint < Constraint
     attrs :table, :name, :columns
 
     def initialize(table, name, columns)
       super
       columns.each { |c| c.table.primary_key_columns << c }
+      table.primary_key_constraints << self
     end
   end
 
   class UniqueConstraint < Constraint
     attrs :table, :name, :columns
+    def initialize(table, name, columns)
+      table.unique_constraints[name] = self
+    end
   end
 
   # Note that #columns is always empty for check constraints
@@ -306,13 +300,14 @@ module MetaDb
     def initialize(table, name, expression)
       super(table, name, [])
       @expression = expression
+      @table.check_constraints[name] = self
     end
   end
 
   class ReferentialConstraint < Constraint
     attrs :referencing_table, :name, :referencing_columns, :referenced_constraint
 
-    # The referencing tabla
+    # The referencing table
     alias_method :referencing_table, :table
 
     # The referencing columns. Can't be empty
@@ -325,21 +320,83 @@ module MetaDb
     def referenced_table() referenced_constraint.table end
 
     # The referenced columns
-    def referenced_columns() referenced_constraints.columns end
+    def referenced_columns() referenced_constraint.columns end
 
     def initialize(referencing_table, name, referencing_columns, referenced_constraint)
       super(referencing_table, name, referencing_columns)
       @referenced_constraint = referenced_constraint
+      table.referential_constraints[name] = self
     end
   end
 
   class Function < DbObject
+    attrs :schema, :name, :owner, :security
+
+    # Schema of the function
+    attr_reader :schema
+
+    # Owner of the function
+    attr_reader :owner
+
+    # Security (:definer or :invoker)
+    attr_reader :security
+
+    # True if security is 'definer'
+    def suid?() security == 'definer' end
+
+    # True if this is a function
+    def function?() true end
+
+    # True if this is a procedure
+    def procedure?() !function? end
+
+    def initialize(schema, name, owner, security)
+      super(name)
+      @schema = schema
+      @owner = owner
+      @security = security.to_sym 
+      if function?
+        schema.functions[name] = self
+      else
+        schema.procedures[name] = self
+      end
+    end
   end
 
-  class Procedure < DbObject
+  class Procedure < Function
+    attrs :schema, :name, :owner, :security
+
+    def function?() false end
   end
 
   class Trigger < DbObject
+    attrs :table, :name, :function, :level, :timing, :events
+
+    # Table of trigger
+    attr_reader :table
+
+    # Trigger function
+    attr_reader :function
+
+    # Trigger level (:stmt or :row)
+    attr_reader :level
+
+    # When trigger is fired (:before, :after, or :instead)
+    attr_reader :timing
+
+    # Array of events (:insert, :update, :delete, or :truncate) causing the trigger to fire 
+    attr_reader :events
+
+    def initialize(table, name, function, level, timing, events)
+      super(name)
+      @table = table
+      @name = name
+      @function = function
+      @level = level.to_sym
+      @timing = timing.to_sym
+      @events = events.split.map(&:to_sym)
+      @table.triggers[name] = self
+    end
   end
 
   CONSTRAINT_KINDS = {

data/lib/meta_db/dump.rb

@@ -1,14 +1,16 @@
 
 require 'indented_io'
 
+require 'meta_db/db_object'
+
 module MetaDb
-  class DbObject
-    def dump
+  class DbObject 
+    def dump(short = false)
       puts self.class.to_s
-      dump_attrs
+      dump_attrs(short)
     end
     
-    def dump_attrs(*attrs)
+    def dump_attrs(short, *attrs)
       attrs = Array(attrs)
       attrs = self.class.attrs if attrs.empty?
       indent {
@@ -16,8 +18,23 @@ module MetaDb
           value = self.send(attr)
           case value
             when Array
-              puts "#{attr}:"
-              indent { value.each { |v| v.dump } }
+              if value.first.is_a?(Symbol)
+                puts "#{attr}: #{value.inspect}"
+              else
+                if short
+                  puts "#{attr}: [#{value.map(&:name).join(", ")}]"
+                else
+                  puts "#{attr}: "
+                  indent { value.each { |v| v.dump } }
+                end
+              end
+            when Hash
+              if short
+                puts "#{attr}: [#{value.values.map(&:name).join(", ")}]"
+              else
+                puts "#{attr}: "
+                indent { value.values.each { |v| v.dump } }
+              end
             when DbObject
               puts "#{attr}: #{value.name} (#{value.class})"
           else
@@ -27,5 +44,11 @@ module MetaDb
       }
     end
   end
+
+  class Constraint < DbObject
+    def dump(short = true) 
+      super(short)
+    end
+  end
 end
 

data/lib/meta_db/version.rb

@@ -1,3 +1,3 @@
 module MetaDb
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meta_db
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-05 00:00:00.000000000 Z
+date: 2021-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Meta model of database