bmg 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6536b48ec764ca63860c01d8f75b689449c0d29
-  data.tar.gz: 4a5f92f4e5dc65f723e419ccbfe89dd424aa27ef
+  metadata.gz: 5cdd3816b79a6f29c387456d9ffdc12d9ae7872e
+  data.tar.gz: 4c30157082a6474c76a156efc7fcdb510f2f2d44
 SHA512:
-  metadata.gz: 3d9fff6fdabf0f3be88b94cff5a7896d0625d82c47772683c3f40156c7cefa46387c95131c261aeb953978aec013e16acae40d203a9554233a61604fea59e5bb
-  data.tar.gz: 6b8b239b5da4002e2ee96a0946acf7b9636f465f15eeac0f5ee227dc4fcccab68fa00b4b4a32a4827b0e9336e5f46a73036397dabe9855e6ea14351a56279fe8
+  metadata.gz: 95290af1dba5768f4a4bfee0357d53ddd70063a6fb6a34ee8c6b329805f44ec1ac49ba0fd5baea0b6946d4e81bf3250b30a954f2b1288c53e0eaa4019687e6d8
+  data.tar.gz: 95fb7f28fbaf62b2f12286857bd04ccc0849d397f085bd366f303572e21a01d6baeb023d4226f56b8223182f075f0c455a3ef06aa7433c677fa5390404c4b9d9

data/lib/bmg/algebra.rb

@@ -82,12 +82,12 @@ module Bmg
     end
     protected :_restrict
 
-    def union(other)
-      _union self.type.union(other.type), other
+    def union(other, options = {})
+      _union self.type.union(other.type), other, options
     end
 
-    def _union(type, other)
-      Operator::Union.new(type, self, other)
+    def _union(type, other, options)
+      Operator::Union.new(type, [self, other], options)
     end
     protected :_union
 

data/lib/bmg/leaf.rb

@@ -14,5 +14,9 @@ module Bmg
       @operand.each(&bl)
     end
 
+    def to_ast
+      [:leaf, operand]
+    end
+
   end
 end

data/lib/bmg/operator/allbut.rb

@@ -41,6 +41,10 @@ module Bmg
         end
       end
 
+      def to_ast
+        [:allbut, operand.to_ast, butlist.dup]
+      end
+
     protected ### optimization
 
       def _restrict(type, predicate)

data/lib/bmg/operator/autosummarize.rb

@@ -38,6 +38,10 @@ module Bmg
         h.values.each(&bl)
       end
 
+      def to_ast
+        [:autosummarize, operand.to_ast, by.dup, sums.dup]
+      end
+
     private
 
       # Returns the tuple determinant.

data/lib/bmg/operator/autowrap.rb

@@ -28,6 +28,7 @@ module Bmg
       def initialize(type, operand, options = {})
         @type = type
         @operand = operand
+        @original_options = options
         @options = DEFAULT_OPTIONS.merge(options)
         @options[:postprocessor] = NoLeftJoinNoise.new(@options[:postprocessor])
       end
@@ -45,6 +46,10 @@ module Bmg
         end
       end
 
+      def to_ast
+        [ :autowrap, operand.to_ast, @original_options.dup ]
+      end
+
     private
 
       def autowrap(tuple)

data/lib/bmg/operator/constants.rb

@@ -29,17 +29,41 @@ module Bmg
         end
       end
 
+      def to_ast
+        [ :constants, operand.to_ast, constants.dup ]
+      end
+
     protected ### optimization
 
       def _restrict(type, predicate)
         top_p, bottom_p = predicate.and_split(constants.keys)
-        if top_p == predicate
+        if top_p.tautology?
+          # push all situation
+          result = operand
+          result = result.restrict(bottom_p) unless bottom_p.tautology?
+          result = result.constants(constants)
+          result
+        elsif (top_p.free_variables - constants.keys).empty?
+          # top_p applies to constants only
+          if eval = top_p.evaluate(constants)
+            result = operand
+            result = result.restrict(bottom_p) unless bottom_p.tautology?
+            result = result.constants(constants)
+            result
+          else
+            Relation.empty(type)
+          end
+        elsif bottom_p.tautology?
+          # push none situation, no optimization possible since top_p
+          # is not a tautology
           super
         else
+          # top_p and bottom_p are complex predicates. Let apply each
+          # of them
           result = operand
-          result = result.restrict(bottom_p) unless bottom_p.tautology?
+          result = result.restrict(bottom_p)
           result = result.constants(constants)
-          result = result.restrict(top_p) unless top_p.tautology?
+          result = result.restrict(top_p)
           result
         end
       rescue Predicate::NotSupportedError

data/lib/bmg/operator/extend.rb

@@ -32,6 +32,10 @@ module Bmg
         end
       end
 
+      def to_ast
+        [ :extend, operand.to_ast, extension.dup ]
+      end
+
     private
 
       def extend_it(tuple)

data/lib/bmg/operator/image.rb

@@ -50,6 +50,28 @@ module Bmg
         end
       end
 
+      def to_ast
+        [ :image, left.to_ast, right.to_ast, as, on, options.dup ]
+      end
+
+    protected ### optimization
+
+      def _restrict(type, predicate)
+        on_as, rest = predicate.and_split([as])
+        if on_as == predicate
+          super
+        else
+          shared, left_only = rest.and_split(on)
+          new_left  = left.restrict(rest)
+          new_right = shared.tautology? ? right : right.restrict(shared)
+          opt = new_left.image(new_right, as, on, options)
+          opt = opt.restrict(on_as) unless on_as.tautology?
+          opt
+        end
+      rescue Predicate::NotSupportedError
+        super
+      end
+
     private
 
       def tuple_project(tuple, on)

data/lib/bmg/operator/project.rb

@@ -40,6 +40,10 @@ module Bmg
         end
       end
 
+      def to_ast
+        [ :project, operand.to_ast, attrlist ]
+      end
+
     protected ### optimization
 
       def _restrict(type, predicate)

data/lib/bmg/operator/rename.rb

@@ -35,6 +35,10 @@ module Bmg
         end
       end
 
+      def to_ast
+        [ :rename, operand.to_ast, renaming.dup ]
+      end
+
     private
 
       def rename(tuple)

data/lib/bmg/operator/restrict.rb

@@ -28,6 +28,10 @@ module Bmg
         end
       end
 
+      def to_ast
+        [ :restrict, operand.to_ast, predicate.sexpr ]
+      end
+
     protected
 
       def _restrict(type, predicate)

data/lib/bmg/operator/union.rb

@@ -6,6 +6,9 @@ module Bmg
     # Returns all tuples of the left operand followed by all
     # tuples from the right operand.
     #
+    # This implementation is actually a NAry-Union, since it handles
+    # an arbitrary number of operands.
+    #
     # By default, this operator strips duplicates, as of relational
     # theory. Please set the `:all` option to true to avoid this
     # behavior and save execution time.
@@ -17,17 +20,16 @@ module Bmg
         all: false
       }
 
-      def initialize(type, left, right, options = {})
+      def initialize(type, operands, options = {})
         @type = type
-        @left = left
-        @right = right
+        @operands = operands
         @options = DEFAULT_OPTIONS.merge(options)
       end
       attr_reader :type
 
     protected
 
-      attr_reader :left, :right, :options
+      attr_reader :operands, :options
 
     public
 
@@ -37,24 +39,48 @@ module Bmg
 
       def each(&bl)
         if all?
-          @left.each(&bl)
-          @right.each(&bl)
+          operands.each do |op|
+            op.each(&bl)
+          end
         else
           seen = {}
-          @left.each do |tuple|
-            yield(tuple)
-            seen[tuple] = true
-          end
-          @right.each do |tuple|
-            yield(tuple) unless seen.has_key?(tuple)
+          operands.each do |op|
+            op.each do |tuple|
+              yield(tuple) unless seen.has_key?(tuple)
+              seen[tuple] = true
+            end
           end
         end
       end
 
+      def to_ast
+        [ :union ] + operands.map(&:to_ast) + [ options.dup ]
+      end
+
     protected ### optimization
 
       def _restrict(type, predicate)
-        left.restrict(predicate).union(right.restrict(predicate))
+        ops = operands
+          .map   {|op| op.restrict(predicate)    }
+          .reject{|op| op.is_a?(Relation::Empty) }
+        case ops.size
+        when 0 then Relation.empty(type)
+        when 1 then ops.first
+        else Union.new(type, ops, options)
+        end
+      end
+
+      def _union(type, other, options)
+        return self if other.is_a?(Relation::Empty)
+        norm_options = DEFAULT_OPTIONS.merge(options)
+        return super unless norm_options == self.options
+        case other
+        when Union
+          return super unless norm_options == other.send(:options)
+          Union.new(type, operands + other.operands, options)
+        else
+          Union.new(type, operands + [other], options)
+        end
       end
 
     end # class Union

data/lib/bmg/relation.rb

@@ -7,6 +7,10 @@ module Bmg
       operand.is_a?(Relation) ? operand : Leaf.new(type, operand)
     end
 
+    def self.empty(type = Type::ANY)
+      Relation::Empty.new(type)
+    end
+
     # Private helper to implement `one` and `one_or_nil`
     def one_or_yield(&bl)
       first = nil
@@ -31,5 +35,31 @@ module Bmg
       one_or_yield{ nil }
     end
 
+    # Converts to an sexpr expression.
+    def to_ast
+      raise "Bmg is missing a feature!"
+    end
+
+    # Returns a String representing the query plan
+    def debug(max_level = nil, on = STDERR)
+      on.puts _debug(to_ast, 1, max_level)
+      self
+    end
+
+  private
+
+    def _debug(ast, level = 1, max_level = nil)
+      return ast.inspect if ast.is_a?(Symbol)
+      return ast.to_s unless ast.is_a?(Array)
+      return ast.to_s unless ast.first.is_a?(Symbol)
+      if max_level && level>max_level
+        "(#{ast.first} ...)"
+      else
+        sep = "  " * level
+        "(#{ast.first}\n" + ast[1..-1].map{|a| _debug(a, 1+level, max_level) }.join("\n").gsub(/^/, sep) + ")"
+      end
+    end
+
   end # module Relation
 end # module Bmg
+require_relative 'relation/empty'

data/lib/bmg/relation/empty.rb

@@ -0,0 +1,65 @@
+module Bmg
+  module Relation
+    #
+    # The empty relation, of a given type.
+    #
+    # This relation implementation exists mostly for optimization
+    # purposes, since knowing that a relation is empty allows
+    # simplifying many expressions.
+    #
+    class Empty
+      include Relation
+
+      def initialize(type)
+        @type = type
+      end
+      attr_reader :type
+
+      def each(&bl)
+      end
+
+      def to_ast
+        [ :empty ]
+      end
+
+    protected ### optimization
+
+      def _allbut(type, *args)
+        Empty.new(type)
+      end
+
+      def _autosummarize(type, *args)
+        Empty.new(type)
+      end
+
+      def _autowrap(type, *args)
+        Empty.new(type)
+      end
+
+      def _extend(type, *args)
+        Empty.new(type)
+      end
+
+      def _image(type, *args)
+        Empty.new(type)
+      end
+
+      def _project(type, *args)
+        Empty.new(type)
+      end
+
+      def _rename(type, *args)
+        Empty.new(type)
+      end
+
+      def _restrict(type, predicate)
+        self
+      end
+
+      def _union(type, other, options)
+        other
+      end
+
+    end # class Empty
+  end # module Relation
+end # module Bmg

data/lib/bmg/sequel/relation.rb

@@ -19,6 +19,10 @@ module Bmg
         @dataset.each(&bl)
       end
 
+      def to_ast
+        [:sequel, @dataset.sql]
+      end
+
     protected ### optimization
 
       def _restrict(type, predicate)

data/lib/bmg/version.rb

@@ -1,7 +1,7 @@
 module Bmg
   module Version
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Bernard Lambeau
@@ -144,6 +144,7 @@ files:
 - lib/bmg/reader/csv.rb
 - lib/bmg/reader/excel.rb
 - lib/bmg/relation.rb
+- lib/bmg/relation/empty.rb
 - lib/bmg/sequel.rb
 - lib/bmg/sequel/relation.rb
 - lib/bmg/type.rb