postspec 0.1.1

data/lib/postspec/frame.rb

@@ -0,0 +1,147 @@
+
+require 'yaml'
+require 'digest'
+
+module Postspec
+  class FrameStack
+    attr_reader :postspec
+    forward_to :postspec, :type
+
+    def initialize(postspec)
+      constrain postspec, Postspec
+      @postspec = postspec
+      @stack = []
+    end
+
+    forward_to :@stack, :empty?, :size, :each, :map
+
+    def push(frame) @stack.push frame; frame end 
+    def pop() @stack.pop end 
+    def top() @stack.last end
+    def dump() 
+      puts self.class
+      indent { @stack.reverse.map(&:dump) }
+    end
+  end
+
+  # TODO: Add #stack and forward #postspec to it
+  class Frame
+    attr_reader :postspec
+    attr_reader :parent
+    attr_reader :search_path
+    def schema() @search_path.first end
+
+    attr_reader :push_sql
+    attr_reader :pop_sql
+    attr_reader :ids
+    attr_reader :anchors
+
+    def initialize(postspec, parent, search_path, push_sql, pop_sql, ids, fox_anchors)
+      constrain postspec, Postspec
+      constrain parent, NilClass, Frame
+      constrain search_path, [String], NilClass
+      constrain push_sql, String, [String], NilClass
+      constrain pop_sql, String, [String], NilClass
+      constrain ids, String => Integer
+      constrain fox_anchors, FixtureFox::Anchors, NilClass
+      @postspec = postspec
+      @parent = parent
+      @search_path = search_path || %w(public)
+      @push_sql = ["set search_path to #{@search_path.join(", ")}"] + Array(push_sql || [])
+      @pop_sql = Array(pop_sql || []) + (parent ? ["set search_path to #{parent.search_path.join(", ")}"] : [])
+      @ids = ids || {}
+      @fox_anchors = fox_anchors || FixtureFox::Anchors.new(@postspec.type)
+      anchors = @fox_anchors.values.map { |anchor| [anchor.name, anchor.id] }.to_h
+      @anchors = (parent ? parent.anchors.merge(anchors) : anchors)
+    end
+
+    # Returns true if this frame is associated with a transaction
+    def transaction?() true end
+
+    def dump()
+      puts self.class
+      indent {
+        puts "search_path: #{search_path}"
+        puts "push_sql:"
+        indent { puts push_sql }
+        puts "pop:sql:"
+        indent { puts pop_sql }
+      }
+    end
+
+  protected
+    attr_reader :fox_anchors
+  end
+
+  class NopFrame < Frame
+    def initialize(parent, search_path)
+      super(parent.postspec, parent, search_path, nil, nil, parent.ids, parent.fox_anchors)
+    end
+  end
+
+  class FoxFrame < Frame
+    attr_reader :fox
+    attr_reader :data
+    alias_method :sql, :push_sql
+
+    # Note FoxFrame::new computes the fox object
+    def initialize(parent, search_path, fox, data, push_sql)
+      @fox = fox
+      @data = data
+      super(parent.postspec, parent, search_path, push_sql, nil, fox.ids, fox.anchors)
+    end
+
+    def self.new(parent, search_path, type, files)
+      fox_signature = self.fox_signature(files)
+      fox = @fox_pool[fox_signature] ||= FixtureFox::Fox.new(type, files, schema: search_path.last)
+
+      # The IDs for the data signature is the minimal set of external IDs used by the Fox object
+      ids = fox.tables.map { |table| (id = parent.ids[table.uid]) ? [table.uid, id] : nil }.compact.to_h
+      data_signature = self.data_signature(fox_signature, ids, fox.referenced_anchors)
+      data = @data_pool[data_signature] ||= fox.data(ids: parent.ids, anchors: parent.send(:fox_anchors))
+      push_sql = @sql_pool[data_signature] ||= data.to_sql(format: :exec, ids: parent.ids, delete: :none)
+
+      object = FoxFrame.allocate
+      object.send(:initialize, parent, search_path, fox, data, push_sql)
+      object
+    end
+
+  private
+    @fox_pool = {}
+    @data_pool = {}
+    @sql_pool = {}
+
+    def self.fox_signature(files)
+      sha256 = Digest::SHA256.new
+      files.sort.each { |source| sha256 << source }
+      sha256.base64digest
+    end
+
+    def self.data_signature(fox_signature, ids, anchors)
+      sha256 = Digest::SHA256.new
+      ids.sort_by(&:first).each { |key, value| sha256 << key << ":" << value.to_s << ";" }
+      anchors.sort_by(&:uid).each { |anchor| sha256 << anchor.uid << "->" << anchor.id.to_s << ";" }
+      fox_signature + ":" + sha256.base64digest
+    end
+  end
+
+  class SeedFrame < Frame
+    def transaction?() false end
+
+    def initialize(postspec, ids, anchors = nil)
+      constrain ids, String => Integer
+      constrain anchors, FixtureFox::Anchors, NilClass
+      super(postspec, nil, nil, [], [], ids, anchors)
+    end
+  end
+
+  class EmptyFrame < Frame
+    def transaction?() false end
+
+    def initialize(postspec)
+      push_sql = pop_sql = postspec.render.delete_tables(postspec.tables.map(&:uid))
+      super(postspec, nil, nil, push_sql, pop_sql, {}, nil)
+    end
+  end
+end
+

data/lib/postspec/render.rb

@@ -0,0 +1,178 @@
+
+module Postspec
+  class Render
+    attr_reader :postspec
+    forward_to :postspec, :conn
+
+    SEED_BUD_TRIGGER_NAME = "postspec_readonly_bud_trg"
+    SEED_BT_TRIGGER_NAME = "postspec_readonly_bt_trg"
+
+    def initialize(postspec)
+      constrain postspec, Postspec
+      @postspec = postspec
+    end
+
+    def truncate_tables(uids) ["truncate #{uids.join(', ')} cascade"] end
+    def delete_tables(uids) uids.map { |uid| "delete from #{uid}" } end # FIXME DUPLICATED
+    def reset_postspec_tables()
+      delete_tables %w(postspec.runs postspec.seeds postspec.inserts postspec.updates postspec.deletes)
+    end
+
+    def postspec_schema(state) raise NotYet end
+
+    def change_triggers(state)
+      constrain state, lambda { |state| [:create, :drop].include?(state) }
+      postspec.tables.map { |table|
+        %w(insert update delete).map { |event|
+          name = "register_#{event}_b#{event[0]}_trg"
+          exist = postspec.meta.exist?("#{table.uid}.#{name}()")
+          if state == :create && !exist
+            ref = (event == "insert" ? "new" : "old")
+            <<~EOS
+              create trigger #{name} before #{event} on #{table.uid}
+              for each row
+              execute function postspec.register_#{event}()
+            EOS
+          elsif state == :drop && exist
+            "drop trigger if exists #{name} on #{table.uid}"
+          else
+            nil
+          end
+        }.compact
+      }.flatten
+    end
+
+    def seed_triggers(state, uids = nil)
+      case state
+        when :create; create_seed_triggers(uids)
+        when :drop; drop_seed_triggers
+      else
+        raise ArgumentError
+      end
+    end
+
+    def drop_seed_triggers
+      postspec.tables.map { |uid|
+        [SEED_BUD_TRIGGER_NAME, SEED_BT_TRIGGER_NAME].map { |trigger|
+          trigger_uid = "#{uid}.#{trigger}()"
+          postspec.meta.exist?(trigger_uid) ? "drop trigger #{trigger} on #{uid}" : nil
+        }.compact
+      }.flatten
+    end
+
+    # Create readonly seed triggers. Readonly triggers are used to raise an
+    # error when seed data are updated, deleted, or truncated. They all call
+    # the common postspec.readonly_failure() function that raises a Postgres
+    # exception
+    def create_seed_triggers(uids)
+      constrain uids, String => [Integer, NilClass]
+      result = []
+      uids.map { |uid, id|
+        bud_trigger = "#{uid}.#{SEED_BUD_TRIGGER_NAME}()"
+        bud_sql = <<~EOS1
+            create trigger #{SEED_BUD_TRIGGER_NAME}
+                before update or delete on #{uid}
+                for each row
+                when (old.id <= #{id})
+                execute function postspec.readonly_failure('#{uid}')
+        EOS1
+        bt_sql = <<~EOS2
+            create trigger postspec_readonly_trigger_bt
+                before truncate on #{uid}
+                execute function postspec.readonly_failure('#{uid}')
+        EOS2
+        [bud_sql, bt_sql, "insert into postspec.seeds (table_uid, record_id) values ('#{uid}', #{id})"]
+      }.flatten
+    end
+
+    def execution_unit(tables, sql)
+      return [] if sql.empty?
+      materialized_views = 
+          tables.select { |uid| uid !~ /^postspec\./ }.map { |uid| 
+            postspec.type.dot(uid).depending_materialized_views 
+          }.flatten.map(&:uid).uniq
+      sql = 
+          tables.map { |uid| "alter table #{uid} disable trigger all" } +
+          sql +
+          tables.map { |uid| "alter table #{uid} enable trigger all" } +
+          materialized_views.map { |uid| "refresh materialized view #{uid}" }
+    end
+
+    def delete_tables(arg)
+      constrain arg, Array, Hash
+      uids = arg.is_a?(Array) ? arg.map { |uid| [uid, 0] }.to_h : arg
+      sql = 
+          uids.map { |uid, id| "delete from #{uid}" + (id > 0 ? " where id > #{id}" : "") } +
+          uids.select { |uid|
+            uid =~ /^postspec\./ ? true : !postspec.type.dot(uid).subtable? 
+          }.map { |uid, id| 
+            "alter table #{uid} alter column id restart" + (id > 0 ? " with #{id+1}" : "")
+          }
+    end
+
+    # FIXME: doesn't seem to be any improvement performance-wise
+    def delete_tables_new(arg)
+      constrain arg, Array, Hash
+      if arg.is_a?(Array)
+        delete_all = arg
+        delete_only = {}
+      else
+        delete_all = []
+        delete_only = {}
+        arg.each { |uid, id| 
+          if id == 0
+            delete_all << uid
+          else
+            delete_only[uid] = id
+          end
+        }
+      end
+      table_alias_index = 0
+      if delete_all.empty?
+        delete_all_sql = []
+      else
+        delete_all_sql = [
+            "with " + 
+            delete_all.map { |uid| 
+              "t#{table_alias_index += 1} as (delete from #{uid} returning 1 as id)" 
+            }.join(", ") + 
+            " select " + (1...table_alias_index).map { |i| "t#{i}.id" }.join(", ") +
+            " from " + (1...table_alias_index).map { |i| "t#{i}" }.join(", ")
+          ] +
+          delete_all.map { |uid| "alter table #{uid} alter column id restart" }
+      end
+      delete_only_sql = 
+          delete_only.map { |uid, id| "delete from #{uid}" + (id > 0 ? " > #{id}" : "") } +
+          delete_only.map { |uid, id| "alter table #{uid} alter column id restart with #{id+1}" }
+      sql = delete_all_sql + delete_only_sql
+#         uids.map { |uid, id| "delete from #{uid}" + (id > 0 ? " > #{id}" : "") } +
+#         uids.map { |uid, id| "alter table #{uid} alter column id restart" }
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/postspec/state.rb

@@ -0,0 +1,112 @@
+module Postspec
+  class State
+    attr_reader :id
+    attr_reader :mode
+    attr_accessor :ready
+    attr_accessor :clean
+    attr_accessor :status
+    attr_reader :created_at
+    attr_reader :updated_at
+
+    def duration() @duraction ||= (1000 * (updated_at - created_at)).round(0) end
+
+    # Maps from table UID to sorted list of record IDs. 
+    # TODO: Are they in use? Should they be used?? Used from postspec!
+    # FIXME: Move to Frame - maybe?
+    def inserted() get_multimap("inserts") end
+    def updated() get_multimap("updates") end
+    def deleted() get_multimap("deletes") end
+
+    # Map from table UID to max record ID for that table
+    def seeds() @seeds ||= get_map("seeds") end
+
+    def refresh() @inserted = @updated = @deleted = @seeds = nil end
+
+    def self.create(conn, mode)
+      id, created_at = conn.tuple <<~EOS
+          insert into postspec.runs (mode) values ('#{mode}') returning id, created_at
+      EOS
+      State.new(conn, id, mode, false, false, nil, created_at, nil)
+    end
+
+    # Return true if change-tables contains any records. It is used to check if
+    # the developer made any changes to the database after a (successful)
+    # postspec run
+    def self.dirty?(conn)
+      conn.value(%(
+        select true as present from postspec.inserts
+        union select true from postspec.updates
+        union select true from postspec.deletes
+      )) || false
+    end
+
+    def self.ensure(conn, mode)
+    end
+
+    def self.read(conn)
+      tuples = conn.tuples <<~EOS
+          select id, mode, ready, clean, status, created_at, updated_at
+          from postspec.runs
+          order by id desc
+          limit 1
+      EOS
+      tuple = tuples.first
+      tuple && State.new(conn, *tuple)
+    end
+
+    def self.write(conn, state)
+      conn.exec <<~EOS
+          update postspec.runs 
+              set ready = #{state.ready},
+                  clean = #{state.clean},
+                  status = #{state.status.nil? ? 'null' : state.status}, 
+                  updated_at = now() at time zone 'UTC'
+              where id = #{state.id}
+      EOS
+      @updated_at = conn.value "select updated_at from postspec.runs where id = #{state.id}"  
+    end
+
+    def dump
+      puts "State"
+      indent {
+        puts "id: #{id.inspect}"
+        puts "mode: #{mode.inspect}"
+        puts "ready: #{ready.inspect}"
+        puts "clean: #{clean.inspect}"
+        puts "status: #{status.inspect}"
+        puts "duration: #{@duration.inspect}"
+        puts "created_at: #{created_at.inspect}"
+      }
+    end
+
+  private
+    attr_reader :conn
+
+    def initialize(conn, id, mode, ready, clean, status, created_at, updated_at)
+      @conn = conn
+      @id = id
+      @mode = mode.to_sym
+      @ready = ready
+      @clean = clean
+      @status = status
+      @created_at = created_at
+      @updated_at = updated_at
+    end
+
+    def get_map(table_name) conn.map "select distinct table_uid, record_id from postspec.#{table_name}" end
+
+    def get_multimap(table_name)
+      h = Hash.new #([])
+      conn.tuples(%(
+          select  distinct table_uid, 
+                  record_id 
+          from    postspec.#{table_name} 
+          order by 
+                  table_uid, record_id
+      )).map { |uid, id|
+        (h[uid] ||= []) << id
+      }
+      h
+    end
+  end
+end

data/lib/postspec/version.rb

@@ -0,0 +1,3 @@
+module Postspec
+  VERSION = "0.1.1"
+end