bmg 0.16.0.pre.rc1 → 0.16.0.pre.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d34f68bbc40a7dd25495cc9964074e20567c8d66
-  data.tar.gz: 9f6beb3a44b9da0a89e1bf523e9b02543e0ea136
+  metadata.gz: 218f9f80891f162695252fbfa56a2e9c2bb7d5f7
+  data.tar.gz: 7c2cf33b9fbc68a20ac08c788fc520b345d8193e
 SHA512:
-  metadata.gz: cd37f8ad39cd7c05e7a725dfb305b8f8a3d74364d5abab1771f4a598c70d1b643b0b7046907f15fba7788645bfab5e302a4f48285b8ae1f6a7f3b7994a6f727b
-  data.tar.gz: ecd95510bde8bc27ed111a917a3e38add365db53faaf62df6f21d2ea2703f8e6d60ffb8428819af31862971cda7fa99112efbe04a610b61d590db1d8dca5c3ef
+  metadata.gz: 83bd84d4505c42a08df4b618f746f39c1548f9aa942ec37682fc95ef383bd8b46c86cb5654f6a858f1b06a1a32176a4b017bde63d2fded55e4ffcdc0157c13cd
+  data.tar.gz: 75adc3b09a8264cf0d56346137688e82bfac9264402fe1c586b42071c470fe0582132a672cd6aa0f8c4699cf8cabfa5728c5e574d54f48121cf16aaeaf9c8064

data/lib/bmg.rb

@@ -32,6 +32,7 @@ module Bmg
   require_relative 'bmg/support'
   require_relative 'bmg/algebra'
   require_relative 'bmg/type'
+  require_relative 'bmg/summarizer'
   require_relative 'bmg/relation'
   require_relative 'bmg/operator'
 

data/lib/bmg/algebra.rb

@@ -71,10 +71,15 @@ module Bmg
     end
 
     def _join(type, right, on)
-      Operator::Join.new(type, self, right, on)
+      right.send(:_joined_with, type, self, on)
     end
     protected :_join
 
+    def _joined_with(type, right, on)
+      Operator::Join.new(type, right, self, on)
+    end
+    protected :_joined_with
+
     def matching(right, on = [])
       _matching self.type.matching(right.type, on), right, on
     end
@@ -112,6 +117,8 @@ module Bmg
     protected :_project
 
     def rename(renaming = {})
+      renaming = renaming.reject{|k,v| k==v }
+      return self if renaming.empty?
       _rename self.type.rename(renaming), renaming
     end
 
@@ -143,6 +150,15 @@ module Bmg
     end
     protected :_restrict
 
+    def summarize(by, summarization = {})
+      _summarize self.type.summarize(by, summarization), by, summarization
+    end
+
+    def _summarize(type, by, summarization)
+      Operator::Summarize.new(type, self, by, summarization)
+    end
+    protected :_summarize
+
     def union(other, options = {})
       return self if other.is_a?(Relation::Empty)
       _union self.type.union(other.type), other, options

data/lib/bmg/algebra/shortcuts.rb

@@ -9,30 +9,46 @@ module Bmg
         self.restrict(predicate)
       end
 
-      def prefix(prefix)
+      def prefix(prefix, options = {})
         raise "Attrlist must be known to use `prefix`" unless self.type.knows_attrlist?
-        renaming = self.type.to_attrlist.each_with_object({}){|a,r|
-          r[a] = :"#{prefix}#{a}"
-        }
+        attrs = self.type.to_attrlist
+        attrs = attrs - options[:but] if options[:but]
+        renaming = Hash[attrs.map{|a| [a, :"#{prefix}#{a}"] }]
         self.rename(renaming)
       end
 
-      def suffix(suffix)
+      def suffix(suffix, options = {})
         raise "Attrlist must be known to use `suffix`" unless self.type.knows_attrlist?
-        renaming = self.type.to_attrlist.each_with_object({}){|a,r|
-          r[a] = :"#{a}#{suffix}"
-        }
+        attrs = self.type.to_attrlist
+        attrs = attrs - options[:but] if options[:but]
+        renaming = Hash[attrs.map{|a| [a, :"#{a}#{suffix}"] }]
         self.rename(renaming)
       end
 
+      def image(right, as = :image, on = [], options = {})
+        return super unless on.is_a?(Hash)
+        renaming = Hash[on.map{|k,v| [v,k] }]
+        self.image(right.rename(renaming), as, on.keys, options)
+      end
+
       def join(right, on = [])
         return super unless on.is_a?(Hash)
-        renaming = on.each_pair.inject({}){|r, (k,v)|
-          r.merge(v => k)
-        }
+        renaming = Hash[on.map{|k,v| [v,k] }]
         self.join(right.rename(renaming), on.keys)
       end
 
+      def matching(right, on = [])
+        return super unless on.is_a?(Hash)
+        renaming = Hash[on.map{|k,v| [v,k] }]
+        self.matching(right.rename(renaming), on.keys)
+      end
+
+      def not_matching(right, on = [])
+        return super unless on.is_a?(Hash)
+        renaming = Hash[on.map{|k,v| [v,k] }]
+        self.not_matching(right.rename(renaming), on.keys)
+      end
+
     end # module Shortcuts
   end # module Algebra
 end # module Bmg

data/lib/bmg/error.rb

@@ -12,4 +12,8 @@ module Bmg
   # Raised when violating types
   class TypeError < Error; end
 
+  # Raised by a type when trying to access attribute list
+  # while unknown
+  class UnknownAttributesError < Error; end
+
 end

data/lib/bmg/operator.rb

@@ -24,51 +24,12 @@ module Bmg
       str
     end
 
-    module Unary
-      include Operator
+  end # module Operator
+end # module Bmg
+require_relative 'operator/shared/unary'
+require_relative 'operator/shared/binary'
+require_relative 'operator/shared/nary'
 
-      attr_reader :operand
-
-      def _visit(parent, visitor)
-        visitor.call(self, parent)
-        operand._visit(self, visitor)
-      end
-
-      def operands
-        [operand]
-      end
-
-    end
-
-    module Binary
-      include Operator
-
-      attr_reader :left, :right
-
-      def _visit(parent, visitor)
-        visitor.call(self, parent)
-        left._visit(self, visitor)
-        right._visit(self, visitor)
-      end
-
-      def operands
-        [left, right]
-      end
-    end
-
-    module Nary
-      include Operator
-
-      attr_reader :operands
-
-      def _visit(parent, visitor)
-        visitor.call(self, parent)
-        operands.each{|op| op._visit(self, visitor) }
-      end
-    end
-
-  end
-end
 require_relative 'operator/allbut'
 require_relative 'operator/autosummarize'
 require_relative 'operator/autowrap'
@@ -84,4 +45,5 @@ require_relative 'operator/project'
 require_relative 'operator/rename'
 require_relative 'operator/restrict'
 require_relative 'operator/rxmatch'
+require_relative 'operator/summarize'
 require_relative 'operator/union'

data/lib/bmg/operator/autowrap.rb

@@ -29,8 +29,7 @@ module Bmg
         @type = type
         @operand = operand
         @original_options = options
-        @options = DEFAULT_OPTIONS.merge(options)
-        @options[:postprocessor] = NoLeftJoinNoise.new(@options[:postprocessor])
+        @options = normalize_options(options)
       end
 
     private
@@ -39,6 +38,10 @@ module Bmg
 
     public
 
+      def same_options?(opts)
+        normalize_options(opts) == options
+      end
+
       def each
         @operand.each do |tuple|
           yield autowrap_tuple(tuple)
@@ -51,26 +54,71 @@ module Bmg
 
     protected ### optimization
 
+      def _autowrap(type, opts)
+        if same_options?(opts)
+          self
+        else
+          super
+        end
+      end
+
+      def _join(type, right, on)
+        if _join_optimizable?(type, right, on)
+          operand.join(right, on).autowrap(options)
+        else
+          super
+        end
+      end
+
+      def _joined_with(type, right, on)
+        if _join_optimizable?(type, right, on)
+          right.join(operand, on).autowrap(options)
+        else
+          super
+        end
+      end
+
+      def _join_optimizable?(type, right, on)
+        # 1. Can't optimize if wrapped roots are used in join clause
+        # 2. Can't optimize if other attributes would be autowrapped
+        (wrapped_roots! & on).empty? && wrapped_roots_of!(right, options).empty?
+      rescue UnknownAttributesError
+        false
+      end
+
       def _page(type, ordering, page_index, opts)
-        return super unless operand.type.knows_attrlist?
-        roots = Support.wrapped_roots(operand.type.to_attrlist, options[:split])
         attrs = ordering.map{|(a,d)| a }
-        if (roots & attrs).empty?
+        if (wrapped_roots! & attrs).empty?
           operand.page(ordering, page_index, opts).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?
+
+        # 2. Can't optimize if new attributes would be autowrapped
+        new_roots = Support.wrapped_roots(renaming.values, options[:split])
+        return super unless new_roots.empty?
+
+        operand.rename(renaming).autowrap(options)
+      rescue UnknownAttributesError
+        super
       end
 
       def _restrict(type, predicate)
-        return super unless operand.type.knows_attrlist?
-        roots = Support.wrapped_roots(operand.type.to_attrlist, options[:split])
         vars = predicate.free_variables
-        if (roots & vars).empty?
+        if (wrapped_roots! & vars).empty?
           operand.restrict(predicate).autowrap(options)
         else
           super
         end
+      rescue UnknownAttributesError
+        super
       end
 
     protected ### inspect
@@ -81,6 +129,21 @@ module Bmg
 
     private
 
+      def wrapped_roots!
+        @wrapped_roots ||= wrapped_roots_of!(operand, options)
+      end
+
+      def wrapped_roots_of!(r, opts)
+        raise UnknownAttributesError unless r.type.knows_attrlist?
+        Support.wrapped_roots(r.type.to_attrlist, opts[:split])
+      end
+
+      def normalize_options(options)
+        opts = DEFAULT_OPTIONS.merge(options)
+        opts[:postprocessor] = NoLeftJoinNoise.new(opts[:postprocessor])
+        opts
+      end
+
       def autowrap_tuple(tuple)
         separator = @options[:split]
         autowrapped = tuple.each_with_object({}){|(k,v),h|
@@ -137,6 +200,7 @@ module Bmg
             raise "Invalid remover `#{remover}`"
           end
         end
+        attr_reader :remover
 
         def call(tuple)
           tuple.each_key do |k|
@@ -155,6 +219,14 @@ module Bmg
         end
         alias :to_s :inspect
 
+        def hash
+          remover.hash
+        end
+
+        def ==(other)
+          other.is_a?(NoLeftJoinNoise) && remover.eql?(other.remover)
+        end
+
       end # NoLeftJoinNoise
 
       module Support

data/lib/bmg/operator/join.rb

@@ -42,6 +42,25 @@ module Bmg
         [ :join, left.to_ast, right.to_ast, on ]
       end
 
+    protected ### optimization
+
+      def _autowrap(type, options)
+        u_left,  left_replaced  = _unautowrap(left, options)
+        u_right, right_replaced = _unautowrap(right, options)
+        if (!left_replaced && !right_replaced)
+          super
+        else
+          u_left.join(u_right, on).autowrap(options)
+        end
+      end
+
+      def _unautowrap(operand, options)
+        return [operand, false] unless operand.is_a?(Operator::Autowrap)
+        return [operand, false] unless operand.same_options?(options)
+        [operand.send(:operand), true]
+      end
+      private :_unautowrap
+
     protected ### inspect
 
       def args

data/lib/bmg/operator/shared/binary.rb

@@ -0,0 +1,22 @@
+module Bmg
+  module Operator
+    module Binary
+      include Operator
+
+    protected
+
+      attr_reader :left, :right
+
+      def _visit(parent, visitor)
+        visitor.call(self, parent)
+        left.send(:_visit, self, visitor)
+        right.send(:_visit, self, visitor)
+      end
+
+      def operands
+        [left, right]
+      end
+
+    end # module Binary
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/shared/nary.rb

@@ -0,0 +1,19 @@
+module Bmg
+  module Operator
+    module Nary
+      include Operator
+
+    protected
+
+      attr_reader :operands
+
+      def _visit(parent, visitor)
+        visitor.call(self, parent)
+        operands.each{|op|
+          op.send(:_visit, self, visitor)
+        }
+      end
+
+    end # module Nary
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/shared/unary.rb

@@ -0,0 +1,21 @@
+module Bmg
+  module Operator
+    module Unary
+      include Operator
+
+    protected
+
+      attr_reader :operand
+
+      def _visit(parent, visitor)
+        visitor.call(self, parent)
+        operand._visit(self, visitor)
+      end
+
+      def operands
+        [operand]
+      end
+
+    end # module Unary
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/summarize.rb

@@ -0,0 +1,77 @@
+module Bmg
+  module Operator
+    #
+    # Summarize operator.
+    #
+    # Makes a summarization by some attributes, applying aggregations
+    # to the corresponding images.
+    #
+    class Summarize
+      include Operator::Unary
+
+      def initialize(type, operand, by, summarization)
+        @type = type
+        @operand = operand
+        @by = by
+        @summarization = Summarize.compile(summarization)
+      end
+
+    protected
+
+      attr_reader :by, :summarization
+
+    public
+
+      def each
+        # summary key => summarization memo, starting with least
+        result = Hash.new{|h,k|
+          h[k] = Hash[@summarization.map{|k,v|
+            [ k, v.least ]
+          }]
+        }
+        # iterate each tuple
+        @operand.each do |tuple|
+          key = TupleAlgebra.project(tuple, @by)
+          # apply them all and create a new memo
+          result[key] = Hash[@summarization.map{|k,v|
+            [ k, v.happens(result[key][k], tuple) ]
+          }]
+        end
+        # Merge result keys and values
+        result.each_pair do |by,sums|
+          tuple = Hash[@summarization.map{|k,v|
+            [ k, v.finalize(sums[k]) ]
+          }].merge(by)
+          yield(tuple)
+        end
+      end
+
+      def to_ast
+        [ :summarize, operand.to_ast, by, summarization ]
+      end
+
+    protected ### inspect
+
+      def args
+        [ 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