pg_meta 0.1.0

data/lib/pg_meta/meta.rb

@@ -0,0 +1,572 @@
+require 'yaml'
+
+module PgMeta
+  class Node
+    # Database object. Equal to self for Database objects
+    attr_reader :root
+
+    # Parent object. nil for Database objects
+    attr_reader :parent
+
+    # Unique name within parent context. This is usually what we understand as
+    # the name of an object but functions have the full signature as "name"
+    attr_reader :name
+
+    def uid()
+      @uid ||= [parent.uid, name].compact.join(".")
+    end
+
+    def guid()
+      @guid ||= [parent.guid, name].compact.join(".")
+    end
+
+    def initialize(parent, name)
+      @root = parent&.root || self
+      @parent = parent
+      @name = name
+      parent && parent.root.send(:add_node, self) # Add object to global database lookup
+    end
+
+    def to_h() raise StandardError, "Undefined method" end
+    def to_yaml() to_h.to_yaml end
+
+    def inspect() "#<#{self.class}:#{guid}>" end
+
+  protected
+    def attrs_to_h(*attrs)
+      h = {}
+      Array(attrs).flatten.each { |attr|
+        value = self.send(attr)
+        h[attr] = 
+            case value
+              when Array
+                if value.first.is_a?(Symbol)
+                  value
+                else
+                  value.map(&:name)
+                end
+              when Hash
+                value.values.map { |element| element.to_h }
+              when Node
+                value.uid
+            else
+              value
+            end
+      }
+      h
+    end
+
+  private
+    def add_node(node) raise StandardError, "Undefined method" end
+  end
+
+  class Database < Node
+    # A database has no UID
+    def uid() nil end
+
+    # GUID is the name of the database
+    def guid() name end
+
+    # Owner of the database. Defined by #load_conn
+    attr_reader :owner
+
+    # Hash of schemas
+    attr_reader :schemas
+
+    # Hash of hidden schemas
+    attr_reader :hidden_schemas
+
+    # Redefine Node#parent
+    def parent() nil end
+
+    def initialize(name, owner = nil)
+      super(nil, name)
+      @owner = owner
+      @schemas = {}
+      @hidden_schemas = {}
+      @nodes = {}
+    end
+
+    # Lookup database object by UID
+    def [](uid) @nodes[uid] end
+
+    # Return true if the given UID exists
+    def exist?(uid) @nodes.key?(uid) end
+
+    # Make Database pretend to be an instance of the PgMeta module
+    def is_a?(klass) klass == PgMeta or super end
+
+    def to_h() attrs_to_h(:name, :owner, :schemas) end
+    def to_marshal() Marshal.dump(self) end
+
+  private
+    def add_node(node)
+      @nodes[node.uid] = node
+    end
+  end
+
+  class Schema < Node
+    # Database of the schema
+    alias_method :database, :parent
+
+    # Owner of the schema
+    attr_reader :owner
+
+    # Hash of tables _and_ views. TODO: Rename #relations
+    attr_reader :tables
+
+    # Hash of views
+    def views() @views ||= @tables.select { |_, table| table.view? } end
+
+    # Hash of functions
+    attr_reader :functions
+
+    # Hash of procedures
+    attr_reader :procedures
+
+    def initialize(database, name, owner, hidden: false)
+      super(database, name)
+      @owner = owner
+      @tables = {}
+      @functions = {}
+      @procedures = {}
+      @hidden = hidden
+      database.schemas[name] = self
+    end
+
+    # True if schema is hidden. This can be set dynamically
+    def hidden?() @hidden end
+
+    # Set hidden property
+    def hidden=(hide)
+      if @hidden
+        database.schemas[name] = database.hidden_schemas.delete(name) if !hide
+      else
+        database.hidden_schemas[name] = database.schemas.delete(name) if hide
+      end
+      @hidden = hide
+    end
+
+    def to_h() attrs_to_h(:name, :owner, :tables, :views, :functions, :procedures) end
+  end
+
+  class Table < Node
+    # Schema of the table
+    alias_method :schema, :parent
+
+    # True iff table is a real table and not a view
+    def table?() true end
+
+    # True iff table is a view
+    def view?() !table? end
+
+    # True iff table is a materialized view
+    def materialized?() false end
+
+    # True if the table/view is insertable
+    def insertable?() @is_insertable end
+
+    # True if the table/view is typed
+    def typed?() @is_typed end
+
+    # Hash of columns
+    attr_reader :columns
+
+    # The primary key column. nil if the table has multiple primary key columns
+    def primary_key_column
+      return @primary_key_column if @primary_key_column != :undefined
+      if primary_key_columns.size == 1
+        @primary_key_column = primary_key_columns.first
+      else
+        @primary_key_column = nil
+      end
+    end
+
+    # List of primary key columns
+    #
+    # Note: Assigned by PrimaryKeyConstraint#initialize
+    attr_reader :primary_key_columns
+
+    # Hash of all constraints
+    attr_reader :constraints
+
+    # List of primary key constraints (there is only one element)
+    attr_reader :primary_key_constraints
+
+    # Hash of unique constraints. Maps from constraint name to UniqueConstraint
+    # object. Note that because constraint names are unpredictable, you'll most
+    # often use +unqiue_constraints.values?
+    attr_reader :unique_constraints
+
+    # Hash of check constraints. Maps from constraint name to CheckConstraint
+    # object object
+    attr_reader :check_constraints
+
+    # Hash of referential constraints. Maps from constraint name to
+    # ReferentialConstraint object
+    attr_reader :referential_constraints
+
+    # Hash of triggers. Maps from trigger name to Trigger object
+    attr_reader :triggers
+
+    # List of tables that directly or indirectly depends on this table. Note
+    # that the tables are sorted by name to make testing in rspec easier
+    def depending_tables() @depending_tables ||= @depending_tables_hash.keys.sort_by(&:uid) end
+
+    # List of views that directly or indirectly depends on this table. This is
+    # the opposite of View#defining_tables. Note that the tables are sorted by
+    # name to make testing in rspec easier
+    def depending_views() @depending_views ||= @depending_views_hash.keys.sort_by(&:uid) end
+
+    def initialize(schema, name, is_insertable, is_typed)
+      super(schema, name)
+      @is_insertable = is_insertable
+      @is_typed = is_typed
+      @columns = {}
+      @primary_key_column = :undefined
+      @primary_key_columns = []
+      @constraints = {}
+      @primary_key_constraints = []
+      @unique_constraints = {}
+      @check_constraints = {}
+      @referential_constraints = {}
+      @triggers = {}
+      @depending_tables_hash = {}
+      @depending_views_hash = {}
+      schema.tables[name] = self
+    end
+
+    def to_h
+      attrs_to_h(
+          :name, :table?, :view?, :materialized?, :insertable?, :typed?,
+          :columns, :primary_key_columns, :constraints,
+          :referential_constraints, :depending_tables, :depending_views, :triggers)
+    end
+
+  protected
+    # Only non-empty for view objects
+    def defining_tables() [] end
+
+  private
+    # Accessed by MetaDb::load_conn
+    def add_depending_table(table)
+      @depending_tables = nil
+      @depending_tables_hash[table] = true
+    end
+
+    # Accessed by MetaDb::load_conn
+    def add_depending_view(view)
+      @depending_views = nil
+      @depending_views_hash[view] = true
+    end
+  end
+
+  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
+
+    def table?() false end
+
+    def initialize(schema, name, is_insertable, is_typed)
+      super
+      @defining_relations = []
+      @defining_tables = []
+    end
+
+    def to_h() 
+      h = super
+      h[:defining_relations] = defining_relations.map(&:uid) 
+      h[:defining_tables] = defining_tables.map(&:uid)
+      h
+    end
+
+  private
+    # Used by MetaDb::load_conn
+    def add_defining_relation(relation)
+      @defining_relations << relation
+      @defining_tables << relation if relation.table?
+    end
+  end
+
+  class MaterializedView < View
+    def materialized?() true end
+  end
+
+  class Column < Node
+    # Table of the column
+    alias_method :table, :parent
+
+    # Ordinal number of the column
+    attr_reader :ordinal
+
+    # Type of the column
+    attr_reader :type
+
+    # Element type if type is an array and nil otherwise
+    attr_reader :element_type
+
+    # Number of dimensions if an array, 0 if not
+    attr_reader :dimensions
+
+    # Default value
+    attr_reader :default
+
+    # True if column is an identity column
+    def identity?() @is_identity end
+
+    # True if column is auto generated
+    def generated?() @is_generated end
+
+    # True if column is nullable
+    def nullable?() @is_nullable end
+
+    # True if column is updatable
+    def updatable?() @is_updatable end
+
+    # True if column is an array
+    def array?() !@element_type.nil? end
+
+    # 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?()
+      return nil if table.primary_key_columns.size != 1
+      table.table? && self == table.primary_key_column || false
+    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
+
+    # True if column is referencing other records. This includes columns in
+    # multi-column references
+    def reference?()
+      @reference ||= !references.empty?
+    end
+
+    # True if column is a single-column reference to another record and is of
+    # type varchar or text
+    def kind?() 
+      @kind ||= 
+          references.size == 1 && 
+          references.first.referencing_columns.size == 1 &&
+          !references.first.referenced_columns.first.primary_key?
+    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, element_type, dimensions, default, 
+        is_identity, is_generated, is_nullable, is_updatable)
+      super(table, name)
+      @type, @element_type, @dimensions, @ordinal, @default, @is_identity, 
+          @is_generated, @is_nullable, @is_updatable =
+            type, element_type, dimensions, ordinal, default, is_identity, 
+            is_generated, is_nullable, is_updatable
+      table.columns[name] = self
+    end
+
+    def to_h()
+      attrs_to_h(
+          :name, :ordinal, :type, :element_type, :dimensions, :default, :identity?, :generated?,
+          :nullable?, :updatable?, :primary_key?, :reference?, :kind?)
+    end
+
+    # Compare columns by table and ordinal. FIXME: Compare by schema too (and what's with the 'super'?)
+    def <=>(other)
+      if other.is_a?(Column) && table == other.table
+        ordinal <=> other.ordinal
+      else
+        super
+      end
+    end
+  end
+
+  class Constraint < Node
+    # Table of the constraint
+    alias_method :table, :parent
+
+    # 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
+    # except not null constraints
+    attr_reader :columns
+
+    # Constraint kind. Either :primary_key, :unique, :check, or :referential
+    def kind() CONSTRAINT_KINDS[self.class] end
+
+    def initialize(table, name, columns)
+      super(table, name)
+      @table = table
+      @columns = columns
+      table.constraints[name] = self
+    end
+
+    def to_h() attrs_to_h(:name, :kind, :columns) end
+  end
+
+   class PrimaryKeyConstraint < Constraint
+    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
+    def initialize(table, name, columns)
+      super
+      table.unique_constraints[name] = self
+    end
+  end
+
+  # Note that #columns is always empty for check constraints
+  class CheckConstraint < Constraint
+    # SQL check expression
+    attr_reader :expression
+
+    # Half-baked SQL-to-ruby expression transpiler
+    def ruby_expression # Very simple
+      @ruby ||= sql.sub(/\((.*)\)/, "\\1").gsub(/\((\w+) IS NOT NULL\)/, "!\\1.nil?").gsub(/ OR /, " || ")
+    end
+
+    # True if this is a not-null check constraint. In that case, #columns will
+    # contain the column which is otherwise empty for CheckConstraint objects.
+    # Note that the column is not registered directly in Postgres meta tables
+    # and have to be parsed from the expression
+    def not_null?() !columns.empty? end
+
+    def initialize(table, name, expression)
+      super(table, name, [])
+      @expression = expression
+      table.check_constraints[name] = self
+      if @expression =~ /^\(\((\S+) IS NOT NULL\)\)$/
+        columns = [table.columns[$1]]
+      else
+        columns = []
+      end
+      super(table, name, columns)
+    end
+
+    def to_h() attrs_to_h(:name, :kind, :expression) end
+  end
+
+  class ReferentialConstraint < Constraint
+    # The referencing table
+    alias_method :referencing_table, :table
+
+    # The referencing columns. Can't be empty
+    alias_method :referencing_columns, :columns
+
+    # The referenced constraint
+    attr_reader :referenced_constraint
+
+    # The referenced table
+    def referenced_table() referenced_constraint.table end
+
+    # The referenced columns
+    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
+
+    def to_h() attrs_to_h(:name, :kind, :referencing_columns, :referenced_constraint) end
+  end
+
+  class Function < Node
+    # Schema of the function
+    alias_method :schema, :parent
+
+    # 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(schema, name)
+      @owner = owner
+      @security = security.to_sym 
+      if function?
+        schema.functions[name] = self
+      else
+        schema.procedures[name] = self
+      end
+    end
+
+    def to_h() attrs_to_h(:name, :owner, :security, :function?) end
+  end
+
+  class Procedure < Function
+    def function?() false end
+  end
+
+  class Trigger < Node
+    # Table of trigger
+    alias_method :table, :parent
+
+    # 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
+
+    # Note that trigger names have a '()' suffixed. This avoid namespace
+    # collisions with field names
+    def initialize(table, name, function, level, timing, events)
+      super(table, name)
+      @name = "#{name}()"
+      @function = function
+      @level = level.to_sym
+      @timing = timing.to_sym
+      @events = events
+      table.triggers[@name] = self
+    end
+
+    def to_h() attrs_to_h(:name, :function, :level, :timing, :events) end
+  end
+
+  CONSTRAINT_KINDS = {
+    PrimaryKeyConstraint => :primary_key,
+    UniqueConstraint => :unique,
+    CheckConstraint => :check,
+    ReferentialConstraint => :referential
+  }
+end
+

data/lib/pg_meta/version.rb

@@ -0,0 +1,3 @@
+module PgMeta
+  VERSION = "0.1.0"
+end

data/lib/pg_meta.rb

@@ -0,0 +1,43 @@
+
+require "pg"
+require "pg_conn"
+
+require "ext/hash.rb"
+
+require "pg_meta/version.rb"
+require "pg_meta/meta.rb"
+require "pg_meta/load_conn.rb"
+require "pg_meta/load_yaml.rb"
+require "pg_meta/dump.rb"
+
+module PgMeta
+  class Error < StandardError; end
+
+  # :call-seq:
+  #   initialize(pg_conn_connection)
+  #   initialize(*pg_conn_initializers)
+  #
+  # Initialize a Database object
+  #
+  def self.new(*args)
+    Database.load_conn(PgConn.ensure(*args))
+  end
+
+  # Load data from a YAML object
+  def self.load_yaml(yaml)
+    Database.load_yaml(yaml)
+  end
+
+  # Load data from a YAML file
+  def self.load_file(file)
+    load_yaml(YAML.load(IO.read file))
+  end
+
+  def self.load_marshal(file)
+    Marshal.load(IO.read file)
+  end
+
+  # Make the PgMeta module pretend to have PgMeta::Database object instances
+  def self.===(element) element.is_a?(PgMeta::Database) or super end
+end
+

data/pg_meta.gemspec

@@ -0,0 +1,50 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pg_meta/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "pg_meta"
+  spec.version       = PgMeta::VERSION
+  spec.authors       = ["Claus Rasmussen"]
+  spec.email         = ["claus.l.rasmussen@gmail.com"]
+
+  spec.summary       = %q{pg_meta gem}
+  spec.description   = %q{pg_meta gem}
+  spec.homepage      = "http://www.nowhere.com/"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+# if spec.respond_to?(:metadata)
+#
+#   spec.metadata["homepage_uri"] = spec.homepage
+# else
+#   raise "RubyGems 2.0 or newer is required to protect against " \
+#     "public gem pushes."
+# end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  # spec.add_dependency GEM [, VERSION]
+  spec.add_dependency "indented_io"
+  spec.add_dependency "pg"
+  spec.add_dependency "pg_conn", "0.2.1"
+  spec.add_dependency "shellopts", "2.0.6"
+
+  # spec.add_development_dependency GEM [, VERSION]
+  
+  # Also un-comment in spec/spec_helper to use simplecov
+  # spec.add_development_dependency "simplecov"
+
+end