bmg 0.17.8 → 0.18.4

data/lib/bmg/operator/autosummarize.rb

@@ -24,7 +24,24 @@ module Bmg
 
     public
 
+      def self.same(*args)
+        Same.new(*args)
+      end
+
+      def self.group(*args)
+        Group.new(*args)
+      end
+
+      def self.y_by_x(*args)
+        YByX.new(*args)
+      end
+
+      def self.ys_by_x(*args)
+        YsByX.new(*args)
+      end
+
       def each(&bl)
+        return to_enum unless block_given?
         h = {}
         @operand.each do |tuple|
           key = key(tuple)
@@ -41,6 +58,12 @@ module Bmg
         [:autosummarize, operand.to_ast, by.dup, sums.dup]
       end
 
+    public ### for internal reasons
+
+      def _count
+        operand._count
+      end
+
     protected
 
       def _restrict(type, predicate)
@@ -175,11 +198,11 @@ module Bmg
         end
 
         def init(v)
-          [v]
+          v.nil? ? [] : [v]
         end
 
         def sum(v1, v2)
-          v1 << v2
+          v2.nil? ? v1 : (v1 << v2)
         end
 
         def term(v)
@@ -211,11 +234,11 @@ module Bmg
         end
 
         def init(v)
-          [v]
+          v.nil? ? [] : [v]
         end
 
         def sum(v1, v2)
-          v1 << v2
+          v2.nil? ? v1 : (v1 << v2)
         end
 
         def term(v)

data/lib/bmg/operator/autowrap.rb

@@ -43,6 +43,7 @@ module Bmg
       end
 
       def each
+        return to_enum unless block_given?
         @operand.each do |tuple|
           yield autowrap_tuple(tuple)
         end
@@ -52,6 +53,12 @@ module Bmg
         [ :autowrap, operand.to_ast, @original_options.dup ]
       end
 
+    public ### for internal reasons
+
+      def _count
+        operand._count
+      end
+
     protected ### optimization
 
       def _autowrap(type, opts)
@@ -86,6 +93,16 @@ module Bmg
         false
       end
 
+      def _matching(type, right, on)
+        if (wrapped_roots! & on).empty?
+          operand.matching(right, on).autowrap(options)
+        else
+          super
+        end
+      rescue UnknownAttributesError
+        super
+      end
+
       def _page(type, ordering, page_index, opts)
         attrs = ordering.map{|(a,d)| a }
         if (wrapped_roots! & attrs).empty?
@@ -97,6 +114,16 @@ module Bmg
         super
       end
 
+      def _project(type, attrlist)
+        if (wrapped_roots! & attrlist).empty?
+          operand.project(attrlist).autowrap(options)
+        else
+          super
+        end
+      rescue UnknownAttributesError
+        super
+      end
+
       def _rename(type, renaming)
         # 1. Can't optimize if renaming applies to a wrapped one
         return super unless (wrapped_roots! & renaming.keys).empty?

data/lib/bmg/operator/constants.rb

@@ -23,6 +23,7 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         @operand.each do |tuple|
           yield extend_it(tuple)
         end
@@ -54,6 +55,12 @@ module Bmg
         [ :constants, operand.to_ast, constants.dup ]
       end
 
+    public ### for internal reasons
+
+      def _count
+        operand._count
+      end
+
     protected ### optimization
 
       def _page(type, ordering, page_index, options)

data/lib/bmg/operator/extend.rb

@@ -26,6 +26,7 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         @operand.each do |tuple|
           yield extend_it(tuple)
         end
@@ -53,6 +54,12 @@ module Bmg
         [ :extend, operand.to_ast, extension.dup ]
       end
 
+    public ### for internal reasons
+
+      def _count
+        operand._count
+      end
+
     protected ### optimization
 
       def _allbut(type, butlist)

data/lib/bmg/operator/group.rb

@@ -32,6 +32,7 @@ module Bmg
     public
 
       def each(&bl)
+        return to_enum unless block_given?
         index = Hash.new{|h,k| h[k] = k.merge(as => empty_group) }
         operand.each do |tuple|
           key = TupleAlgebra.allbut(tuple, attrs)

data/lib/bmg/operator/image.rb

@@ -46,6 +46,7 @@ module Bmg
     public
 
       def each(*args, &bl)
+        return to_enum unless block_given?
         (options[:jit_optimized] ? self : jit_optimize)._each(*args, &bl)
       end
 
@@ -99,9 +100,10 @@ module Bmg
           key = tuple_project(t, on)
           index[key].operand << tuple_image(t, on)
         end
-        if options[:array]
+        if opt = options[:array]
+          sorter = to_sorter(opt)
           index = index.each_with_object({}) do |(k,v),ix|
-            ix[k] = v.to_a
+            ix[k] = sorter ? v.to_a.sort(&sorter) : v.to_a
           end
         end
         index
@@ -154,8 +156,32 @@ module Bmg
         end
       end
 
+    public ### for internal reasons
+
+      def _count
+        left._count
+      end
+
     protected ### optimization
 
+      def _allbut(type, butlist)
+        if butlist.include?(as)
+          left.allbut(butlist - [as])
+        elsif (butlist & on).empty?
+          left.allbut(butlist).image(right, as, on, options)
+        else
+          super
+        end
+      end
+
+      def _matching(type, m_right, m_on)
+        if m_on.include?(as)
+          super
+        else
+          left.matching(m_right, m_on).image(right, as, on, options)
+        end
+      end
+
       def _page(type, ordering, page_index, opts)
         if ordering.map{|(k,v)| k}.include?(as)
           super
@@ -166,6 +192,14 @@ module Bmg
         end
       end
 
+      def _project(type, attrlist)
+        if attrlist.include?(as)
+          super
+        else
+          left.project(attrlist)
+        end
+      end
+
       def _restrict(type, predicate)
         on_as, rest = predicate.and_split([as])
         if rest.tautology?
@@ -227,6 +261,11 @@ module Bmg
         Relation::InMemory.new(image_type, Set.new)
       end
 
+      def to_sorter(opt)
+        return nil unless opt.is_a?(Array)
+        Ordering.new(opt).comparator
+      end
+
     public
 
       def to_s

data/lib/bmg/operator/join.rb

@@ -25,6 +25,7 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         index = Hash.new
         right.each_with_object(index) do |t, index|
           key = tuple_project(t, on)

data/lib/bmg/operator/matching.rb

@@ -23,6 +23,7 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         index = Hash.new
         right.each_with_object(index) do |t, index|
           key = tuple_project(t, on)

data/lib/bmg/operator/not_matching.rb

@@ -23,6 +23,7 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         index = Hash.new
         right.each_with_object(index) do |t, index|
           key = tuple_project(t, on)

data/lib/bmg/operator/page.rb

@@ -30,6 +30,7 @@ module Bmg
     public
 
       def each(&bl)
+        return to_enum unless block_given?
         page_size = options[:page_size]
         @operand.to_a
           .sort(&comparator)
@@ -45,13 +46,7 @@ module Bmg
     protected ### inspect
 
       def comparator
-        ->(t1, t2) {
-          ordering.each do |(attr,direction)|
-            c = t1[attr] <=> t2[attr]
-            return (direction == :desc ? -c : c) unless c==0
-          end
-          0
-        }
+        Ordering.new(@ordering).comparator
       end
 
       def args

data/lib/bmg/operator/project.rb

@@ -29,9 +29,10 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         seen = {}
         @operand.each do |tuple|
-          projected = project(tuple)
+          projected = tuple_project(tuple)
           unless seen.has_key?(projected)
             yield(projected)
             seen[projected] = true
@@ -74,7 +75,7 @@ module Bmg
 
     private
 
-      def project(tuple)
+      def tuple_project(tuple)
         tuple.dup.delete_if{|k,_| !@attrlist.include?(k) }
       end
 

data/lib/bmg/operator/rename.rb

@@ -29,16 +29,17 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         @operand.each do |tuple|
-          yield rename(tuple, renaming)
+          yield rename_tuple(tuple, renaming)
         end
       end
 
       def insert(arg)
         case arg
-        when Hash       then operand.insert(rename(arg, reverse_renaming))
+        when Hash       then operand.insert(rename_tuple(arg, reverse_renaming))
         when Relation   then operand.insert(arg.rename(reverse_renaming))
-        when Enumerable then operand.insert(arg.map{|t| rename(t, reverse_renaming) })
+        when Enumerable then operand.insert(arg.map{|t| rename_tuple(t, reverse_renaming) })
         else
           super
         end
@@ -46,7 +47,7 @@ module Bmg
 
       def update(arg)
         case arg
-        when Hash then operand.update(rename(arg, reverse_renaming))
+        when Hash then operand.update(rename_tuple(arg, reverse_renaming))
         else
           super
         end
@@ -60,6 +61,12 @@ module Bmg
         [ :rename, operand.to_ast, renaming.dup ]
       end
 
+    public ### for internal reasons
+
+      def _count
+        operand._count
+      end
+
     protected ### optimization
 
       def _page(type, ordering, page_index, options)
@@ -82,7 +89,7 @@ module Bmg
 
     private
 
-      def rename(tuple, renaming)
+      def rename_tuple(tuple, renaming)
         tuple.each_with_object({}){|(k,v),h|
           h[renaming[k] || k] = v
           h

data/lib/bmg/operator/restrict.rb

@@ -26,6 +26,7 @@ module Bmg
       end
 
       def each
+        return to_enum unless block_given?
         @operand.each do |tuple|
           yield(tuple) if @predicate.evaluate(tuple)
         end

data/lib/bmg/operator/rxmatch.rb

@@ -32,6 +32,7 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         @operand.each do |tuple|
           against = attrs.map{|a| tuple[a] }.join(" ")
           matcher = self.matcher

data/lib/bmg/operator/summarize.rb

@@ -13,7 +13,7 @@ module Bmg
         @type = type
         @operand = operand
         @by = by
-        @summarization = Summarize.compile(summarization)
+        @summarization = Summarizer.summarization(summarization)
       end
 
     protected
@@ -23,6 +23,7 @@ module Bmg
     public
 
       def each
+        return to_enum unless block_given?
         # summary key => summarization memo, starting with least
         result = Hash.new{|h,k|
           h[k] = Hash[@summarization.map{|k,v|
@@ -56,22 +57,6 @@ module Bmg
         [ by, summarization ]
       end
 
-    private
-
-      # Compile a summarization hash so that every value is a Summarizer
-      # instance
-      def self.compile(summarization)
-        Hash[summarization.map{|k,v|
-          summarizer = case v
-          when Summarizer then v
-          when Symbol     then Summarizer.send(v, k)
-          else
-            raise ArgumentError, "Unexpected summarizer #{k} => #{v}"
-          end
-          [ k, summarizer ]
-        }]
-      end
-
     end # class Summarize
   end # module Operator
 end # module Bmg

data/lib/bmg/operator/transform.rb

@@ -23,11 +23,12 @@ module Bmg
 
     protected
 
-      attr_reader :transformation
+      attr_reader :transformation, :options
 
     public
 
       def each
+        return to_enum unless block_given?
         t = transformer
         @operand.each do |tuple|
           yield t.call(tuple)
@@ -40,6 +41,43 @@ module Bmg
 
     protected ### optimization
 
+      def _allbut(type, butlist)
+        # `allbut` can always be pushed down the tree. unlike
+        # `extend` the Proc that might be used cannot use attributes
+        # in butlist, so it's safe to strip them away.
+        if transformer.knows_attrlist?
+          # We just need to clean the transformation
+          attrlist = transformer.to_attrlist
+          thrown = attrlist & butlist
+          t = transformation.dup.reject{|k,v| thrown.include?(k) }
+          operand.allbut(butlist).transform(t, options)
+        else
+          operand.allbut(butlist).transform(transformation, options)
+        end
+      end
+
+      def _project(type, attrlist)
+        if transformer.knows_attrlist?
+          t = transformation.dup.select{|k,v| attrlist.include?(k) }
+          operand.project(attrlist).transform(t, options)
+        else
+          operand.project(attrlist).transform(transformation, options)
+        end
+      end
+
+      def _restrict(type, predicate)
+        return super unless transformer.knows_attrlist?
+        top, bottom = predicate.and_split(transformer.to_attrlist)
+        if top == predicate
+          super
+        else
+          operand
+            .restrict(bottom)
+            .transform(transformation, options)
+            .restrict(top)
+        end
+      end
+
     protected ### inspect
 
       def args