bud 0.0.7 → 0.0.8

data/lib/bud/meta_algebra.rb

@@ -0,0 +1,168 @@
+require 'rubygems'
+require 'bud'
+require 'bud/depanalysis'
+
+module MetaAlgebra
+  state do
+    table :alg_path, [:from, :to, :path, :last_rule, :tag, :lastop]
+    scratch :clean_dep, [:body, :head, :rule_id] => [:tag, :lastop]
+
+    scratch :rule_nm, [:rule_id] => [:tag]
+
+    table :apj1, [:from, :head, :rule_id, :path, :tag, :tag2, :lastop]
+    table :apj2, [:from, :head, :rule_id] => [:path, :tag, :lastop]
+    table :seq_lattice, [:left, :right, :directional]
+    table :seq_lattice_closure, [:left, :right, :directional, :dist]
+    table :lub, [:left, :right] => [:result]
+    table :seq_lattice_result, [:left, :right, :result]
+    table :upper_bound, [:left, :right, :bound, :height]
+    table :lps, alg_path.schema
+  end
+
+  bootstrap do
+    seq_lattice <= [
+      [:M, :A, false],
+      [:M, :N, false],
+      [:A, :D, false],
+      [:N, :D, false],
+      [:N, :A, true] #,
+
+      # disabled, for now
+      #[:A, :D, true],
+      #[:D, :G, false],
+      #[:A, :G, false]
+    ]
+
+  end
+
+  def max_of(a, b)
+    if b > a
+      b
+    else
+      a
+    end
+  end
+  
+  bloom :debug do
+    #stdio <~ upper_bound{|b| ["UPPERB: #{b.inspect}"]}
+    #stdio <~ seq_lattice_closure{|c| ["SLC: #{c.inspect}"]}
+    #stdio <~ jlr {|j| ["JLR: #{j.inspect}"]}
+    #stdio <~ lub {|l| ["LUB #{l.inspect}, left class #{l.left.class}"]}
+  end
+
+  bloom :lattice_rules do
+    seq_lattice_closure <= seq_lattice {|l| [l.left, l.right, l.directional, 1]}
+    seq_lattice_closure <= seq_lattice {|l| [l.left, l.left, false, 0]}
+    seq_lattice_closure <= seq_lattice {|l| [l.right, l.right, false, 0]}
+    seq_lattice_closure <= (seq_lattice_closure * seq_lattice).pairs(:right => :left) do |c, l|
+      [c.left, l.right, (c.directional or l.directional), c.dist + 1]
+    end
+
+    # the join lattice is symmetric
+    lub <= seq_lattice_closure {|l| [l.left, l.right, l.right]}
+    lub <= seq_lattice_closure {|l| [l.right, l.left, l.right] unless l.directional}
+
+    # still need a LUB for incomparable types.
+    upper_bound <= (seq_lattice_closure * seq_lattice_closure).map do |c1, c2|
+      if c1.right == c2.right and seq_lattice_closure.find_all{|c| c.left == c1.left and c.right == c2.left}.empty?
+        unless c1.left == c1.right or c2.left == c2.right
+          [c1.left, c2.left, c1.right, max_of(c1.dist, c2.dist) + 1]
+        end
+      end
+    end
+
+    temp :jlr  <= upper_bound.argagg(:min, [upper_bound.left, upper_bound.right], upper_bound.height)
+    lub <+ jlr {|j| [j.left, j.right, j.bound] unless lub.map{|l| [l.left, l.right]}.include? [j.left, j.right] }
+  end
+
+  def get_tag(nm, op)
+    if nm and op == '<~'
+      :D
+    elsif nm
+      :N
+    elsif op == '<~'
+      :A
+    else
+      :M
+    end
+  end
+
+  def in_prefix(node, path)
+    path.split("|").include? node
+  end
+ 
+  bloom :make_paths do
+    rule_nm <= t_depends.reduce({}) do |memo, i|
+      tag = get_tag(i.nm, i.op)
+      memo[i.rule_id] = tag if memo[i.rule_id].nil?
+      memo[i.rule_id] = tag if tag == :N or tag == :A
+      memo
+    end
+
+    clean_dep <= (t_depends * rule_nm).pairs(:rule_id => :rule_id) do |dep, rn|
+      unless dep.lhs == 'alg_path'
+        [dep.body, dep.lhs, dep.rule_id, rn.tag, dep.op]
+      end
+    end
+
+    alg_path <= clean_dep.map do |dep|
+      [dep.body, dep.head, "#{dep.body}|#{dep.head}", dep.rule_id, dep.tag, dep.lastop]
+    end
+
+    lps <= (alg_path * t_provides).pairs(:from => :interface) do |a, p|
+      if p.input
+        a
+      end
+    end
+
+    apj1 <= (alg_path * clean_dep).pairs(:to => :body) do |a, c|
+      [a.from, c.head, c.rule_id, a.path, a.tag, c.tag, a.lastop]
+    end
+    apj2 <= (apj1 * lub).pairs(:tag => :left, :tag2 => :right)
+    alg_path <= apj2.map do |p, l|
+      unless in_prefix(p.head, p.path)
+        [p.from, p.head, "#{p.path}|#{p.head}", p.rule_id, l.result, p.lastop]
+      end
+    end
+  end 
+end
+
+module MetaReports
+  state do
+    table :global_property, [:from, :to, :tag, :c1, :c2]
+    scratch :paths, [:from, :to] => [:cnt]
+    table :tags, [:from, :to, :tag, :cnt]
+    table :d_begins, [:from, :tag, :path, :len, :lastop]
+    table :ap, d_begins.schema
+    scratch :a_preds, d_begins.schema + [:fullpath]
+  end
+
+  bloom :loci do
+    # one approach: for every paths that 'turns D', identify the last async edge before
+    # the critical transition.  ordering this edge prevents diffluence.
+    # find the first point of diffluence in each paths: d_begins already does this.
+    # for each "D"-entry in d_begins, find the longest subpath ending in an async rule.
+    a_preds <= (d_begins * ap).pairs(:from => :from) do |b, a|
+      if a.len < b.len and a.tag == :A and b.path.index(a.path) == 0 and a.lastop == "<~" and b.tag == :D
+        [a.from, a.tag, a.path, a.len, a.lastop, b.path]
+      end
+    end
+  end
+
+  bloom do
+    paths <= alg_path.group([:from, :to], count(:tag))
+    tags <= alg_path.group([:from, :to, :tag], count())
+    global_property <= (paths * tags).pairs(:from => :from, :to => :to, :cnt => :cnt) do |p, t|
+      [t.from, t.to, t.tag, p.cnt, t.cnt]
+    end
+
+    ap <= (alg_path * t_provides).pairs(:from => :interface) do |p, pr| 
+      if pr.input
+        [p.from, p.tag, p.path, p.path.split("|").length, p.lastop]
+      end
+    end
+
+    d_begins <= ap.argagg(:min, [:from, :tag], :len)
+  end
+end
+

data/lib/bud/monkeypatch.rb

@@ -1,4 +1,5 @@
-# We monkeypatch Module to add support for Bloom state and code declarations.
+# We monkeypatch Module to add support for Bloom's syntax additions: "state",
+# "bloom", and "bootstrap" blocks, plus the "import" statement.
 class Module
   # import another module and assign to a qualifier symbol: <tt>import MyModule => :m</tt>
   def import(spec)
@@ -15,11 +16,13 @@ class Module
     # To correctly expand qualified references to an imported module, we keep a
     # table with the local bind names of all the modules imported by this
     # module. To handle nested references (a.b.c.d etc.), the import table for
-    # module X points to X's own nested import table.
+    # module X points to X's own nested import table. If a single module
+    # attempts to import multiple sub-modules with the same local name, we merge
+    # the import tables of all the modules.
     @bud_import_tbl ||= {}
-    child_tbl = mod.bud_import_table
-    raise Bud::CompileError, "import symbol #{local_name} already in use" if @bud_import_tbl.has_key? local_name
-    @bud_import_tbl[local_name] = child_tbl.clone # XXX: clone needed?
+    prev_tbl = @bud_import_tbl[local_name]
+    child_tbl = NestedRefRewriter.build_import_table(mod)
+    @bud_import_tbl[local_name] = NestedRefRewriter.merge_import_table(prev_tbl, child_tbl)
 
     rewritten_mod_name = ModuleRewriter.do_import(self, mod, local_name)
     self.module_eval "include #{rewritten_mod_name}"
@@ -88,3 +91,27 @@ class Module
     return r
   end
 end
+
+
+module Enumerable
+  public
+  # Support for renaming collections and their schemas
+  def rename(new_tabname, new_schema=nil)
+    budi = (respond_to?(:bud_instance)) ? bud_instance : nil
+    if new_schema.nil? and respond_to?(:schema)
+      new_schema = schema
+    end
+    scr = Bud::BudScratch.new(new_tabname.to_s, budi, new_schema)
+    scr.uniquify_tabname
+    scr.merge(self, scr.storage)
+    scr
+  end
+
+  public
+  # We rewrite "map" calls in Bloom blocks to invoke the "pro" method
+  # instead. This is fine when applied to a BudCollection; when applied to a
+  # normal Enumerable, just treat pro as an alias for map.
+  def pro(&blk)
+    map(&blk)
+  end
+end

data/lib/bud/rewrite.rb

@@ -7,11 +7,11 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
     @bud_instance = bud_instance
     @ops = {:<< => 1, :< => 1, :<= => 1}
     @monotonic_whitelist = {
-      :== => 1, :+ => 1, :<= => 1, :- => 1, :< => 1, :> => 1,
+      :== => 1, :+ => 1, :<= => 1, :- => 1, :< => 1, :> => 1, :~ => 1,
       :* => 1, :pairs => 1, :matches => 1, :combos => 1, :flatten => 1,
       :lefts => 1, :rights => 1, :map => 1, :flat_map => 1, :pro => 1,
-      :schema => 1, :keys => 1, :values => 1, :cols => 1, :key_cols => 1,
-      :val_cols => 1, :payloads => 1, :~ => 1
+      :schema => 1, :cols => 1, :key_cols => 1, :val_cols => 1,
+      :payloads => 1, :tabname => 1, :+@ => 1
     }
     @temp_ops = {:-@ => 1, :~ => 1, :+@ => 1}
     @tables = {}
@@ -40,7 +40,12 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       # :defn block -- this is where we expect Bloom statements to appear
       do_rule(exp)
     else
-      if recv and recv.class == Sexp
+      if op == :notin
+        # a <= b.m1.m2.notin(c, ... ) ..
+        # b contributes positively to a, but c contributes negatively.
+        notintab = args[1][2].to_s # args == (:arglist (:call, nil, :c, ...))
+        @tables[notintab] = true
+      elsif recv and recv.class == Sexp
         # for CALM analysis, mark deletion rules as non-monotonic
         @nm = true if op == :-@
         # don't worry about monotone ops, table names, table.attr calls, or accessors of iterator variables
@@ -90,7 +95,7 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
     t = exp[1].to_s
     # If we're called on a "table-like" part of the AST that doesn't correspond
     # to an extant table, ignore it.
-    @tables[t] = @nm if @bud_instance.tables.has_key? t.to_sym
+    @tables[t] = @nm if @bud_instance.tables.has_key? t.to_sym and not @tables[t]
     drain(exp)
     return t
   end
@@ -103,7 +108,8 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       rhs = collect_rhs(pro_rules)
       rhs_pos = rhs
     else
-      # need a deep copy of the rules so we can keep a version without AttrName Rewrite
+      # need a deep copy of the rules so we can keep a version without AttrName
+      # Rewrite
       pro_rules2 = Marshal.load(Marshal.dump(pro_rules))
       rhs = collect_rhs(pro_rules)
       reset_instance_vars
@@ -114,7 +120,7 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   end
 
   # We want to rewrite "map" calls on BudCollections to "pro" calls. It is hard
-  # to do this accurately (issue #225), so we just replace map calls liberally
+  # to do this precisely (issue #225), so we just replace map calls liberally
   # and define Enumerable#pro as an alias for "map".
   def map2pro(exp)
     if exp[1] and exp[1][0] and exp[1][0] == :iter \
@@ -143,7 +149,8 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
     @bud_instance = bud_instance
   end
 
-  # some icky special-case parsing to find mapping between collection names and iter vars
+  # some icky special-case parsing to find mapping between collection names and
+  # iter vars
   def process_iter(exp)
     if exp[1] and exp[1][0] == :call
       gather_collection_names(exp[1])
@@ -207,7 +214,7 @@ end
 # Given a table of renames from x => y, replace all calls to "x" with calls to
 # "y" instead. We don't try to handle shadowing due to block variables: if a
 # block references a block variable that shadows an identifier in the rename
-# tbl, it should appear as an :lvar node rather than a :call, so we should be
+# table, it should appear as an :lvar node rather than a :call, so we should be
 # okay.
 class CallRewriter < SexpProcessor # :nodoc: all
   def initialize(rename_tbl)
@@ -243,14 +250,39 @@ end
 class NestedRefRewriter < SexpProcessor # :nodoc: all
   attr_accessor :did_work
 
-  def initialize(import_tbl)
+  def initialize(mod)
     super()
     self.require_empty = false
     self.expected = Sexp
-    @import_tbl = import_tbl
+
+    @import_tbl = NestedRefRewriter.build_import_table(mod)
     @did_work = false
   end
 
+  # If module Y imports Z as "z" and X includes Y, X can contain a reference
+  # to "z.foo". Hence, when expanding nested references in X, we want to merge
+  # the import tables of X and any modules that X includes; however, we can
+  # skip the Bud module, as well as any modules generated via the import
+  # system.
+  def self.build_import_table(mod)
+    child_tbl = mod.bud_import_table.clone
+    mod.modules.each do |m|
+      next if m == Bud
+      next if m.instance_variable_get('@bud_imported_module')
+
+      child_tbl = NestedRefRewriter.merge_import_table(child_tbl,
+                                                       m.bud_import_table)
+    end
+    child_tbl
+  end
+
+  def self.merge_import_table(old, new)
+    old ||= {}
+    old.merge(new) do |key, old_val, new_val|
+      NestedRefRewriter.merge_import_table(old_val, new_val)
+    end
+  end
+
   def process_call(exp)
     return exp if @import_tbl.empty?
     tag, recv, meth_name, args = exp
@@ -572,7 +604,7 @@ module ModuleRewriter # :nodoc: all
     # and returns a matching ast.
     # hence we run it before the other rewrites.
     ast = ast_process_withs(mod)
-    ast = ast_flatten_nested_refs(ast, mod.bud_import_table)
+    ast = ast_flatten_nested_refs(ast, mod)
     ast = ast_process_temps(ast, mod)
 
     ast, new_mod_name = ast_rename_module(ast, import_site, mod, local_name)
@@ -584,6 +616,13 @@ module ModuleRewriter # :nodoc: all
     str = Ruby2Ruby.new.process(ast)
     rv = import_site.module_eval str
     raise Bud::CompileError unless rv.nil?
+
+    # Set an instance variable to allow modules produced by the import/rewrite
+    # process to be distinguished from "normal" Ruby modules.
+    mod = import_site.module_eval new_mod_name
+    raise Bud::CompileError unless mod.class == Module
+    mod.instance_variable_set("@bud_imported_module", true)
+
     return new_mod_name
   end
 
@@ -651,8 +690,8 @@ module ModuleRewriter # :nodoc: all
 
   # If this module imports a submodule and binds it to :x, references to x.t1
   # need to be flattened to the mangled name of x.t1.
-  def self.ast_flatten_nested_refs(ast, import_tbl)
-    NestedRefRewriter.new(import_tbl).process(ast)
+  def self.ast_flatten_nested_refs(ast, mod)
+    NestedRefRewriter.new(mod).process(ast)
   end
 
   # Handle temp collections defined in the module's Bloom blocks.

data/lib/bud/server.rb

@@ -1,8 +1,10 @@
 require 'socket'
 
 class Bud::BudServer < EM::Connection #:nodoc: all
-  def initialize(bud)
+  def initialize(bud, channel_filter)
     @bud = bud
+    @channel_filter = channel_filter
+    @filter_buf = {}
     @pac = MessagePack::Unpacker.new
     super
   end
@@ -16,6 +18,24 @@ class Bud::BudServer < EM::Connection #:nodoc: all
       message_received(obj)
     end
 
+    # apply the channel filter to each channel's pending tuples
+    buf_leftover = {}
+    @filter_buf.each do |tbl_name, buf|
+      if @channel_filter
+        accepted, saved = @channel_filter.call(tbl_name, buf)
+      else
+        accepted = buf
+        saved = []
+      end
+
+      unless accepted.empty?
+        @bud.inbound[tbl_name] ||= []
+        @bud.inbound[tbl_name] += accepted
+      end
+      buf_leftover[tbl_name] = saved unless saved.empty?
+    end
+    @filter_buf = buf_leftover
+
     begin
       @bud.tick_internal if @bud.running_async
     rescue Exception
@@ -24,8 +44,8 @@ class Bud::BudServer < EM::Connection #:nodoc: all
       # error isn't best though -- we should do better (#74).
       puts "Exception handling network messages: #{$!}"
       puts "Inbound messages:"
-      @bud.inbound.each do |m|
-        puts "    #{m[1].inspect} (channel: #{m[0]})"
+      @bud.inbound.each do |chn_name, t|
+        puts "    #{t.inspect} (channel: #{chn_name})"
       end
       @bud.inbound.clear
     end
@@ -40,6 +60,7 @@ class Bud::BudServer < EM::Connection #:nodoc: all
     end
 
     @bud.rtracer.recv(obj) if @bud.options[:rtrace]
-    @bud.inbound << obj
+    @filter_buf[obj[0].to_sym] ||= []
+    @filter_buf[obj[0].to_sym] << obj[1]
   end
 end

data/lib/bud/state.rb

@@ -1,8 +1,7 @@
 module Bud
   ######## methods for registering collection types
   private
-  def define_collection(name, &block)
-    # Don't allow duplicate collection definitions
+  def define_collection(name)
     if @tables.has_key? name
       raise Bud::CompileError, "collection already exists: #{name}"
     end
@@ -11,19 +10,19 @@ module Bud
     # previously-defined method names.
     reserved = eval "defined?(#{name})"
     unless reserved.nil?
-      raise Bud::CompileError, "symbol :#{name} reserved, cannot be used as table name"
+      raise Bud::CompileError, "symbol :#{name} reserved, cannot be used as collection name"
     end
     self.singleton_class.send(:define_method, name) do |*args, &blk|
-      unless blk.nil? then
-        return @tables[name].pro(&blk)
-      else
+      if blk.nil?
         return @tables[name]
+      else
+        return @tables[name].pro(&blk)
       end
     end
   end
-  
+
   public
-	
+
   def input # :nodoc: all
     true
   end
@@ -38,12 +37,12 @@ module Bud
     scratch(name, schema)
   end
 
-  # declare an in-memory, non-transient collection.  default schema <tt>[:key] => [:val]</tt>. 
+  # declare an in-memory, non-transient collection.  default schema <tt>[:key] => [:val]</tt>.
   def table(name, schema=nil)
     define_collection(name)
     @tables[name] = Bud::BudTable.new(name, self, schema)
   end
-  
+
   # declare a syncronously-flushed persistent collection.  default schema <tt>[:key] => [:val]</tt>.
   def sync(name, storage, schema=nil)
     define_collection(name)
@@ -58,7 +57,7 @@ module Bud
       raise Bud::Error, "unknown synchronous storage engine #{storage.to_s}"
     end
   end
-  
+
   def store(name, storage, schema=nil)
     define_collection(name)
     case storage
@@ -79,7 +78,7 @@ module Bud
     define_collection(name)
     @tables[name] = Bud::BudScratch.new(name, self, schema)
   end
-  
+
   def readonly(name, schema=nil)
     define_collection(name)
     @tables[name] = Bud::BudReadOnly.new(name, self, schema)
@@ -91,7 +90,7 @@ module Bud
     # defer schema definition until merge
     @tables[name] = Bud::BudTemp.new(name, self, nil, true)
   end
-  
+
   # declare a transient network collection.  default schema <tt>[:address, :val] => []</tt>
   def channel(name, schema=nil, loopback=false)
     define_collection(name)
@@ -114,7 +113,7 @@ module Bud
     @tables[name] = Bud::BudFileReader.new(name, filename, delimiter, self)
   end
 
-  # declare a collection to be auto-populated every +period+ seconds.  schema <tt>[:key] => [:val]</tt>.  
+  # declare a collection to be auto-populated every +period+ seconds.  schema <tt>[:key] => [:val]</tt>.
   # rhs of statements only.
   def periodic(name, period=1)
     define_collection(name)

data/lib/bud/storage/dbm.rb

@@ -41,6 +41,7 @@ module Bud
     end
 
     def [](key)
+      check_enumerable(key)
       key_s = MessagePack.pack(key)
       val_s = @dbm[key_s]
       if val_s
@@ -51,13 +52,14 @@ module Bud
     end
 
     def has_key?(k)
+      check_enumerable(k)
       key_s = MessagePack.pack(k)
       return true if @dbm.has_key? key_s
       return @delta.has_key? k
     end
 
     def include?(tuple)
-      key = @key_colnums.map{|k| tuple[k]}
+      key = get_key_vals(tuple)
       value = self[key]
       return (value == tuple)
     end
@@ -110,11 +112,11 @@ module Bud
 
     def merge_to_db(buf)
       buf.each do |key,tuple|
-        merge_tuple(key, tuple)
+        merge_tuple_to_db(key, tuple)
       end
     end
 
-    def merge_tuple(key, tuple)
+    def merge_tuple_to_db(key, tuple)
       val = val_cols.map{|c| tuple[cols.index(c)]}
       key_s = MessagePack.pack(key)
       val_s = MessagePack.pack(val)
@@ -140,16 +142,19 @@ module Bud
     end
 
     def insert(tuple)
-      key = @key_colnums.map{|k| tuple[k]}
-      merge_tuple(key, tuple)
+      key = get_key_vals(tuple)
+      merge_tuple_to_db(key, tuple)
     end
 
     alias << insert
 
     # Remove to_delete and then add pending to db
     def tick
+      raise Bud::Error, "orphaned tuples in @delta for #{@tabname}" unless @delta.empty?
+      raise Bud::Error, "orphaned tuples in @new_delta for #{@tabname}" unless @new_delta.empty?
+
       @to_delete.each do |tuple|
-        k = @key_colnums.map{|c| tuple[c]}
+        k = get_key_vals(tuple)
         k_str = MessagePack.pack(k)
         cols_str = @dbm[k_str]
         unless cols_str.nil?
@@ -168,8 +173,14 @@ module Bud
       flush
     end
 
-    def method_missing(sym, *args, &block)
-      @dbm.send sym, *args, &block
+    public
+    def length
+      @dbm.length
+    end
+
+    public
+    def empty?
+      @dbm.empty?
     end
   end
 end

data/lib/bud/storage/tokyocabinet.rb

@@ -47,6 +47,7 @@ module Bud
     end
 
     def [](key)
+      check_enumerable(key)
       key_s = MessagePack.pack(key)
       val_s = @hdb[key_s]
       if val_s
@@ -57,13 +58,14 @@ module Bud
     end
 
     def has_key?(k)
+      check_enumerable(k)
       key_s = MessagePack.pack(k)
       return true if @hdb.has_key? key_s
       return @delta.has_key? k
     end
 
     def include?(tuple)
-      key = @key_colnums.map{|k| tuple[k]}
+      key = get_key_vals(tuple)
       value = self[key]
       return (value == tuple)
     end
@@ -116,11 +118,11 @@ module Bud
 
     def merge_to_hdb(buf)
       buf.each do |key,tuple|
-        merge_tuple(key, tuple)
+        merge_tuple_to_hdb(key, tuple)
       end
     end
 
-    def merge_tuple(key, tuple)
+    def merge_tuple_to_hdb(key, tuple)
       val = val_cols.map{|c| tuple[cols.index(c)]}
       key_s = MessagePack.pack(key)
       val_s = MessagePack.pack(val)
@@ -144,16 +146,20 @@ module Bud
     end
 
     def insert(tuple)
-      key = @key_colnums.map{|k| tuple[k]}
-      merge_tuple(key, tuple)
+      tuple = prep_tuple(tuple)
+      key = get_key_vals(tuple)
+      merge_tuple_to_hdb(key, tuple)
     end
 
     alias << insert
 
     # Remove to_delete and then add pending to HDB
     def tick
+      raise Bud::Error, "orphaned tuples in @delta for #{@tabname}" unless @delta.empty?
+      raise Bud::Error, "orphaned tuples in @new_delta for #{@tabname}" unless @new_delta.empty?
+
       @to_delete.each do |tuple|
-        k = @key_colnums.map{|c| tuple[c]}
+        k = get_key_vals(tuple)
         k_str = MessagePack.pack(k)
         cols_str = @hdb[k_str]
         unless cols_str.nil?
@@ -173,8 +179,12 @@ module Bud
       @hdb.tranbegin
     end
 
-    def method_missing(sym, *args, &block)
-      @hdb.send sym, *args, &block
+    def length
+      @hdb.length
+    end
+
+    def empty?
+      @hdb.empty?
     end
   end
 end