bud 0.1.0.pre1 → 0.9.0

data/lib/bud/executor/join.rb

@@ -14,7 +14,7 @@ module Bud
       @origpreds = preds
       @localpreds = nil
       @selfjoins = []
-      @input_bufs=[[],[]]
+      @input_bufs = [[],[]]
       @missing_keys = Set.new
       the_join = nil
 
@@ -30,7 +30,8 @@ module Bud
         end
       end
 
-      # check for self-joins: we currently only handle 2 instances of the same table per rule
+      # check for self-joins: we currently only handle 2 instances of the same
+      # table per rule
       counts = @all_rels_below.reduce({}) do |memo, r|
         memo[r.elem_name] ||= 0
         memo[r.elem_name] += 1
@@ -57,7 +58,7 @@ module Bud
       setup_preds(preds) unless preds.empty?
       setup_state
 
-      super(@tabname,@bud_instance,nil,@cols)
+      super(@tabname, @bud_instance, nil, @cols)
     end
 
     public
@@ -249,7 +250,7 @@ module Bud
           next if (skips.include? pred)
           # assumption of left-deep joins here
           if pred[1][0] != @rels[1].tabname
-            raise "Expected rhs table to be #{@rels[1].tabname}, not #{pred[1][0]}"
+            raise Bud::Error, "expected rhs table to be #{@rels[1].tabname}, not #{pred[1][0]}"
           end
           rfield = right[pred[1][1]]
           if left_is_array
@@ -296,7 +297,7 @@ module Bud
       else
         offsets = [@relnames.index(source.elem_name)]
       end
-      raise "item #{item.inspect} inserted into join from unknown source #{source.elem_name}" if offsets == $EMPTY
+      raise Bud::Error, "item #{item.inspect} inserted into join from unknown source #{source.elem_name}" if offsets == $EMPTY
       offsets.each do |offset|
         buf = @input_bufs[offset]
         buf << item
@@ -342,12 +343,14 @@ module Bud
         invalidate << self
       end
 
-      # The distinction between a join node and other stateful elements is that when a join node needs a rescan
-      # it doesn't tell all its sources to rescan. In fact, it doesn't have to pass a rescan request up to a source,
-      # because if a target needs a rescan, the join node has all the state necessary to feed the downstream node. And
-      # if a source node is in rescan, then at run-time only the state associated with that particular source node
-      # @hash_tables[offset] will be cleared, and will get filled up again because that source will rescan anyway.
-
+      # The distinction between a join node and other stateful elements is that
+      # when a join node needs a rescan it doesn't tell all its sources to
+      # rescan. In fact, it doesn't have to pass a rescan request up to a
+      # source, because if a target needs a rescan, the join node has all the
+      # state necessary to feed the downstream node. And if a source node is in
+      # rescan, then at run-time only the state associated with that particular
+      # source node @hash_tables[offset] will be cleared, and will get filled up
+      # again because that source will rescan anyway.
       invalidate_tables(rescan, invalidate)
     end
 
@@ -406,7 +409,7 @@ module Bud
     public
     def flush
       @input_bufs.each_with_index do |buf, offset|
-        flush_buf(buf,offset) if buf.length > 0
+        flush_buf(buf, offset) if buf.length > 0
       end
     end
 
@@ -582,11 +585,10 @@ module Bud
       end
       super(rellist, bud_instance, preds)
       set_block(&blk)
-      @cols =  rellist[0].cols
+      @cols = rellist[0].cols
       @exclude = Set.new
     end
 
-
     def positionwise_preds(bud_instance, rels)
       # pairwise colnames, for the minimum number of columns from either
       return [] if rels[0].cols.length != rels[1].cols.length
@@ -614,23 +616,24 @@ module Bud
 
     def stratum_end
       flush
-      # Scan through all the cached left rel values, and push out those that are not in exclude
-      @hash_tables[0].each_value do|s| #
+      # Scan through all the cached left rel values, and push out those that are
+      # not in exclude
+      @hash_tables[0].each_value do |s|
         s.each do |item|
           next if @exclude.member? item
           @outputs.each do |ou|
             if ou.class <= Bud::PushElement
-              ou.insert(item,self)
+              ou.insert(item, self)
             elsif ou.class <= Bud::BudCollection
-              ou.do_insert(item,ou.new_delta)
+              ou.do_insert(item, ou.new_delta)
             else
-              raise "Expected either a PushElement or a BudCollection"
+              raise Bud::Error, "expected either a PushElement or a BudCollection"
             end
           end
           # for all the following, o is a BudCollection
-          @deletes.each{|o| o.pending_delete([item])} unless item.nil?
-          @delete_keys.each{|o| o.pending_delete_keys([item])} unless item.nil?
-          @pendings.each{|o| o.pending_merge([item])} unless item.nil?
+          @deletes.each{|o| o.pending_delete([item])}
+          @delete_keys.each{|o| o.pending_delete_keys([item])}
+          @pendings.each{|o| o.pending_merge([item])}
         end
       end
     end

data/lib/bud/metrics.rb

@@ -7,7 +7,7 @@ else
   $mod = CSV
 end
 
-# metrics are reported in a nested hash representing a collection of relational tables.
+# Metrics are reported in a nested hash representing a collection of relational tables.
 # The metrics hash has the following form:
 # - key of the metrics hash is the name of the metric (table), e.g. "tickstats", "collections", "rules", etc.
 # - value of the metrics is itself a hash holding the rows of the table, keyed by key columns.

data/lib/bud/monkeypatch.rb

@@ -80,6 +80,9 @@ class Module
     raise Bud::CompileError unless (spec.class <= Hash and spec.length == 1)
     mod, local_name = spec.first
     raise Bud::CompileError unless (mod.class <= Module and local_name.class <= Symbol)
+    if mod.class <= Class
+      raise Bud::CompileError, "import must be used with a Module, not a Class"
+    end
 
     # A statement like this:
     #   import MyModule => :m
@@ -98,19 +101,18 @@ class Module
 
     mod, local_name = spec.first
 
-    if self.instance_methods.include? local_name.to_s or self.instance_methods.include? local_name
-      raise Bud::CompileError, "#{local_name} is already taken."
+    if self.method_defined? local_name
+      raise Bud::CompileError, "#{local_name} is already taken"
     else
       src = %Q{
         def #{local_name}
           @#{local_name}
         end
         def #{local_name}=(val)
-          raise "Type Error: expecting an instance of #{mod}" unless val.kind_of? #{mod}
+          raise Bud::Error, "type error: expecting an instance of #{mod}" unless val.kind_of? #{mod}
           @#{local_name} = val
         end
       }
-      #puts src
       self.class_eval src
     end
 
@@ -142,7 +144,7 @@ class Module
     # If no block name was specified, generate a unique name
     if block_name.nil?
       @block_id ||= 0
-      block_name = "#{Module.get_class_name(self)}__#{@block_id.to_s}"
+      block_name = "#{Module.get_class_name(self)}__#{@block_id}".to_sym
       @block_id += 1
     else
       unless block_name.class <= Symbol
@@ -157,25 +159,25 @@ class Module
 
     # Don't allow duplicate named bloom blocks to be defined within a single
     # module; this indicates a likely programmer error.
-    if instance_methods(false).include? meth_name
+    if instance_methods(false).include?(meth_name) ||
+       instance_methods(false).include?(meth_name.to_sym)
       raise Bud::CompileError, "duplicate named bloom block: '#{block_name}' in #{self}"
     end
     ast = Source.read_block(caller[0]) # pass in caller's location via backtrace
     # ast corresponds only to the statements of the block. Wrap it in a method
     # definition for backward compatibility for now.
     # First wrap ast in a block if it is only a single statement
-    unless ast.nil?
-      ast = s(:block, ast) unless ast.sexp_type == :block
-      ast = s(:defn, meth_name.to_sym, s(:args), s(:scope, ast))
-      unless self.respond_to? :__bloom_asts__
-        def self.__bloom_asts__;
-          @__bloom_asts__ ||= {}
-          @__bloom_asts__
-        end
+    ast = s(:block) if ast.nil?
+    ast = s(:block, ast) unless ast.sexp_type == :block
+    ast = s(:defn, meth_name.to_sym, s(:args), s(:scope, ast))
+    unless self.respond_to? :__bloom_asts__
+      def self.__bloom_asts__
+        @__bloom_asts__ ||= {}
+        @__bloom_asts__
       end
-      __bloom_asts__[meth_name] = ast
-      define_method(meth_name.to_sym, &block)
     end
+    __bloom_asts__[meth_name] = ast
+    define_method(meth_name.to_sym, &block)
   end
 
   private
@@ -202,19 +204,6 @@ 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

data/lib/bud/rebl.rb

@@ -9,7 +9,7 @@ TABLE_TYPES = ["table", "scratch", "channel", "loopback", "periodic", "sync", "s
 # The class to which rebl adds user-specified rules and declarations.
 class ReblBase
   include Bud
-  attr_accessor:port, :ip
+  attr_accessor :port, :ip
 
   # Support for breakpoints
   state { scratch :rebl_breakpoint }
@@ -195,9 +195,10 @@ end
 class LibRebl
   attr_accessor :rules, :state
   attr_reader :ip, :port, :rebl_class_inst
-  @@builtin_tables = [:stdio, :t_depends, :periodics_tbl, :t_cycle, :localtick,
-                      :t_provides, :t_rules, :t_depends_tc, :t_stratum,
-                      :rebl_breakpoint]
+  @@builtin_tables = [:stdio, :periodics_tbl, :halt, :localtick,
+                      :t_depends, :t_cycle, :t_provides, :t_rules,
+                      :t_depends_tc, :t_stratum, :t_underspecified,
+                      :t_table_info, :t_table_schema, :rebl_breakpoint]
   @@classid = 0
 
   def initialize(ip, port)

data/lib/bud/rewrite.rb

@@ -12,8 +12,9 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
           :* => 1, :pairs => 1, :matches => 1, :combos => 1, :flatten => 1,
           :lefts => 1, :rights => 1, :map => 1, :flat_map => 1, :pro => 1,
           :cols => 1,  :key_cols => 1, :val_cols => 1, :payloads => 1, :~ => 1,
-          :lambda => 1, :tabname => 1
-      }
+          :lambda => 1, :tabname => 1,
+          :ip_port => 1, :port => 1, :ip => 1
+    }
     @temp_ops = {:-@ => 1, :~ => 1, :+@ => 1}
     @tables = {}
     @nm = false
@@ -21,6 +22,7 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
     @collect = false
     @rules = []
     @depends = []
+    @nm_funcs_called = false
     super()
   end
 
@@ -76,9 +78,15 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
         end
         # 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
-        unless @monotonic_whitelist[op] or op_is_field_name or (recv and recv.first == :lvar) or op.to_s.start_with?("__")
-          @nm = true
+        if recv
+          # don't worry about monotone ops, table names, table.attr calls, or accessors of iterator variables
+          unless @monotonic_whitelist[op] or op_is_field_name or recv.first == :lvar or op.to_s.start_with?("__")
+            @nm = true if recv
+          end
+        else
+          # function called (implicit receiver = Bud instance) in a user-defined code block. Check if it is
+          # non-monotonic (like budtime, that produces a new answer every time it is called)
+          @nm_funcs_called = true unless @monotonic_whitelist[op]
         end
       end
       if @temp_ops[op]
@@ -110,6 +118,7 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   def reset_instance_vars
     @tables = {}
     @nm = false
+    @nm_funcs_called = false
     @temp_op = nil
   end
 
@@ -122,7 +131,7 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       op = op.to_s
     end
 
-    @rules << [@bud_instance, @rule_indx, lhs, op, rule_txt, rule_txt_orig]
+    @rules << [@bud_instance, @rule_indx, lhs, op, rule_txt, rule_txt_orig, @nm_funcs_called]
     @tables.each_pair do |t, non_monotonic|
       @depends << [@bud_instance, @rule_indx, lhs, op, t, non_monotonic]
     end
@@ -172,7 +181,7 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       if exp[1][1] and exp[1][1][1] and exp[1][1][1][2] == :map
         exp[1][1][1][2] = :pro
       end
-    end  
+    end
     exp
   end
 
@@ -246,7 +255,6 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
       @collnames << exp[2]
     elsif exp[2] and exp[2] == :rename
       arglist, namelit, schemahash = exp[3]
-      # and add name to @collnames
       @collnames << namelit[1]
     else
       exp.each { |e| gather_collection_names(e) if e and e.class <= Sexp }
@@ -288,12 +296,12 @@ class TempExpander < SexpProcessor # :nodoc: all
   attr_reader :tmp_tables
   attr_accessor :did_work
 
+  KEYWORD = :temp
+
   def initialize
     super()
     self.require_empty = false
     self.expected = Sexp
-    @keyword = :temp
-
     @tmp_tables = []
     @did_work = false
   end
@@ -322,7 +330,7 @@ class TempExpander < SexpProcessor # :nodoc: all
         end
 
         _, recv, meth, meth_args = n
-        if meth == @keyword and recv.nil?
+        if meth == KEYWORD and recv.nil?
           block[i] = rewrite_me(n)
           @did_work = true
         end
@@ -331,12 +339,13 @@ class TempExpander < SexpProcessor # :nodoc: all
     s(tag, name, args, scope)
   end
 
+  private
   def fix_temp_decl(iter_body)
     if iter_body.first.sexp_type == :call
       call_node = iter_body.first
 
       _, recv, meth, meth_args = call_node
-      if meth == @keyword and recv.nil?
+      if meth == KEYWORD and recv.nil?
         _, lhs, op, rhs = meth_args.sexp_body.first
 
         old_rhs_body = rhs.sexp_body
@@ -350,20 +359,6 @@ class TempExpander < SexpProcessor # :nodoc: all
     return nil
   end
 
-  def get_state_meth(klass)
-    return if @tmp_tables.empty?
-    block = s(:block)
-
-    @tmp_tables.each do |t|
-      args = s(:arglist, s(:lit, t.to_sym))
-      block << s(:call, nil, :temp, args)
-    end
-
-    meth_name = Module.make_state_meth_name(klass).to_s + "__" + @keyword.to_s
-    return s(:defn, meth_name.to_sym, s(:args), s(:scope, block))
-  end
-
-  private
   def rewrite_me(exp)
     _, recv, meth, args = exp
 
@@ -380,137 +375,3 @@ class TempExpander < SexpProcessor # :nodoc: all
     return s(:call, new_recv, nest_op, nest_args)
   end
 end
-
-# We do four things here for each "with" block
-# 1) Remove it from the AST
-# 2) Use rewrite_me in the parent class to get the collection name pushed onto @tmp_tables.
-# 3) Extract the definition of the "with" collection and push it onto @with_defns
-# 4) Extract the rules in the body of the "with" block and push it onto @with_rules
-
-class WithExpander < TempExpander
-  attr_reader :with_rules, :with_defns
-  def initialize
-    super()
-    @keyword = :with
-    @with_rules = []
-    @with_defns = []
-  end
-
-  def process_defn(exp)
-    tag, name, args, scope = exp
-    if name.to_s =~ /^__bloom__.+/
-      block = scope[1]
-
-      block.each_with_index do |n,i|
-        if i == 0
-          raise Bud::CompileError if n != :block
-          next
-        end
-
-        # temp declarations are misparsed if the RHS contains certain constructs
-        # (e.g., group, "do |f| ... end" rather than "{|f| ... }").  Rewrite to
-        # correct the misparsing.
-        if n.sexp_type == :iter
-          block[i] = nil
-          iter_body = n.sexp_body
-          n = fix_temp_decl(iter_body)
-          @with_defns.push n
-          @did_work = true unless n.nil?
-        end
-
-        _, recv, meth, meth_args = n
-        if meth == @keyword and recv.nil?
-          block[i] = nil
-          n = rewrite_me(n)
-          @with_defns.push n
-          @did_work = true unless n.nil?
-        end
-      end
-    end
-    block.compact! unless block.nil? # remove the nils that got pulled out
-
-    return s(tag, name, args, scope)
-  end
-
-  def get_state_meth(klass)
-    return if @tmp_tables.empty?
-    block = s(:block)
-
-    t = @tmp_tables.pop
-    args = s(:arglist, s(:lit, t.to_sym))
-    block << s(:call, nil, :temp, args)
-
-    meth_name = Module.make_state_meth_name(klass).to_s + "__" + @keyword.to_s
-    return s(:defn, meth_name.to_sym, s(:args), s(:scope, block))
-  end
-
-  private
-  def rewrite_me(exp)
-    _, recv, meth, args = exp
-
-    raise Bud::CompileError unless recv == nil
-    nest_call = args.sexp_body.first
-    raise Bud::CompileError unless nest_call.sexp_type == :call
-
-    nest_recv, nest_op, nest_args = nest_call.sexp_body
-    raise Bud::CompileError unless nest_recv.sexp_type == :lit
-
-    tmp_name = nest_recv.sexp_body.first
-    @tmp_tables.push tmp_name
-    nest_block = args.sexp_body[1]
-    if nest_block.first == :call
-      # a one-rule block doesn't get wrapped in a block.  wrap it ourselves.
-      nest_block = s(:block, nest_block)
-    end
-    @with_rules.push nest_block
-    new_recv = s(:call, nil, tmp_name, s(:arglist))
-    return s(:call, new_recv, nest_op, nest_args)
-  end
-
-  undef get_state_meth
-
-  public
-  def get_state_meth(klass)
-    return if @tmp_tables.empty?
-    block = s(:block)
-
-    args = s(:arglist, s(:lit, @tmp_tables.pop.to_sym))
-    block << s(:call, nil, :temp, args)
-
-    meth_name = Module.make_state_meth_name(klass).to_s + "__" + @keyword.to_s
-    return s(:defn, meth_name.to_sym, s(:args), s(:scope, block))
-  end
-end
-
-class DefnRenamer < SexpProcessor # :nodoc: all
-  def initialize(local_name, rename_tbl)
-    super()
-    self.require_empty = false
-    self.expected = Sexp
-    @local_name = local_name
-    @rename_tbl = rename_tbl
-  end
-
-  def process_defn(exp)
-    tag, name, args, scope = exp
-    name_s = name.to_s
-
-    if name_s =~ /^__bootstrap__.+$/
-      new_name = name_s.sub(/^(__bootstrap__)(.+)$/, "\\1#{@local_name}__\\2")
-    elsif name_s =~ /^__state\d+__/
-      new_name = name_s.sub(/^(__state\d+__)(.*)$/, "\\1#{@local_name}__\\2")
-    elsif name_s =~ /^__bloom__.+$/
-      new_name = name_s.sub(/^(__bloom__)(.+)$/, "\\1#{@local_name}__\\2")
-    else
-      new_name = "#{@local_name}__#{name_s}"
-    end
-
-    new_name = new_name.to_sym
-    @rename_tbl[name] = new_name
-
-    # Note that we don't bother to recurse further into the AST: we're only
-    # interested in top-level :defn nodes.
-    s(tag, new_name, args, scope)
-  end
-end
-

data/lib/bud/source.rb

@@ -5,13 +5,13 @@ require 'bud/errors'
 module Source
   $cached_file_info = Struct.new(:curr_file, :lines, :last_state_bloom_line).new
 
-  #Reads the block corresponding to the location (string of the form "file:line_num").
-  #Returns an ast for the block
+  # Reads the block corresponding to the location (string of the form
+  # "file:line_num").  Returns an ast for the block.
   def Source.read_block(location)
-    raise Bud::CompileError, "Source must be present in a file; cannot read interactive shell or eval block" if location.start_with? '('
+    raise Bud::IllegalSourceError, "source must be present in a file; cannot read interactive shell or eval block" if location.start_with? '('
     location =~ /^(.*):(\d+)/
     filename, num = $1, $2.to_i
-    raise Bud::Error, "Couldn't determine filename from backtrace" if filename.nil?
+    raise Bud::IllegalSourceError, "couldn't determine filename from backtrace" if filename.nil?
     lines = cache(filename, num)
     # Note: num is 1-based.
 
@@ -59,7 +59,7 @@ module Source
       }
       $cached_file_info.lines = retval
     end
-    retval # array of lines.
+    retval # array of lines
   end
 
   # Tok is string tokenizer that extracts a substring matching the

data/lib/bud/state.rb

@@ -1,6 +1,7 @@
 module Bud
   ######## methods for registering collection types
-  def define_collection(name)
+  private
+  def check_collection_name(name)
     if @tables.has_key? name
       raise Bud::CompileError, "collection already exists: #{name}"
     end
@@ -11,6 +12,11 @@ module Bud
     unless reserved.nil?
       raise Bud::CompileError, "symbol :#{name} reserved, cannot be used as collection name"
     end
+  end
+
+  def define_collection(name)
+    check_collection_name(name)
+
     self.singleton_class.send(:define_method, name) do |*args, &blk|
       if blk.nil?
         return @tables[name]
@@ -20,6 +26,7 @@ module Bud
     end
   end
 
+  public
   def input # :nodoc: all
     true
   end
@@ -32,7 +39,7 @@ module Bud
   def interface(mode, name, schema=nil)
     define_collection(name)
     t_provides << [name.to_s, mode]
-    @tables[name] = (mode ? Bud::BudInputInterface : BudOutputInterface).new(name, self, schema)
+    @tables[name] = (mode ? BudInputInterface : BudOutputInterface).new(name, self, schema)
   end
 
   # declare an in-memory, non-transient collection.  default schema <tt>[:key] => [:val]</tt>.
@@ -41,13 +48,13 @@ module Bud
     @tables[name] = Bud::BudTable.new(name, self, schema)
   end
 
-  # declare a collection-generating expression.  default schema <tt>[:key] => [:val]</tt>. 
+  # declare a collection-generating expression.  default schema <tt>[:key] => [:val]</tt>.
   def coll_expr(name, expr, schema=nil)
     define_collection(name)
     @tables[name] = Bud::BudCollExpr.new(name, self, expr, schema)
   end
-  
-  # declare a syncronously-flushed persistent collection.  default schema <tt>[:key] => [:val]</tt>. 
+
+  # declare a syncronously-flushed persistent collection.  default schema <tt>[:key] => [:val]</tt>.
   def sync(name, storage, schema=nil)
     define_collection(name)
     case storage
@@ -85,12 +92,6 @@ module Bud
     @tables[name] = Bud::BudReadOnly.new(name, self, schema)
   end
 
-  def signal(name, schema=nil)
-    define_collection(name)
-    @tables[name] = Bud::BudSignal.new(name, self, schema)
-  end
-
-
   # declare a scratch in a bloom statement lhs.  schema inferred from rhs.
   def temp(name)
     define_collection(name)
@@ -104,7 +105,7 @@ module Bud
     @tables[name] = Bud::BudChannel.new(name, self, schema, loopback)
     @channels[name] = @tables[name]
   end
-  
+
   # declare a transient network collection that delivers facts back to the
   # current Bud instance. This is syntax sugar for a channel that always
   # delivers to the IP/port of the current Bud instance. Default schema