bmg 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31a0ebe96dae3801143c423e0b014bc9dee902b9
-  data.tar.gz: 6c4c003b7af5154301bf64f68f12e2bd7ab880f9
+  metadata.gz: 67347fd77660f79d3e4d4bfa09199881b03e94ae
+  data.tar.gz: c3f52c0219760d8382738106e78bf997633abf93
 SHA512:
-  metadata.gz: acaf31901fc7b3da45dfce9d7e1e23f1fe4ca86437db8c954538e3817fb4f4297825177ceb77d2fba60afabbb57e199fd0e932b1e944c5a750882c568fe0ea48
-  data.tar.gz: b27cd4e4d9132ac73a5fa27b0e03fa6badd197283b369aab9a463519df3b3f5092e3a669c856528063baa7f2a7eadc98c72aadd2a2a11b40f0a9614f0793c9cf
+  metadata.gz: b4e91ccd011024741b24b84d31e6b4e23feda9a9b6e7398cf4ad2f534b05205f1f4fef6003635fe31232d9dfabc8852d81642b76535a046aa1f309132b770a61
+  data.tar.gz: c9ed01a662aec36ba2b77ca315051d512950fa008c09fd9b3abc8f30dba1d2bb4d881856d0d39919084461141756bbced69afe7a58c365382b34626fc35ec4fe

data/lib/bmg/algebra.rb

@@ -82,6 +82,15 @@ module Bmg
     end
     protected :_matching
 
+    def not_matching(right, on = [])
+      _not_matching self.type.not_matching(right, on), right, on
+    end
+
+    def _not_matching(type, right, on)
+      Operator::NotMatching.new(type, self, right, on)
+    end
+    protected :_not_matching
+
     def page(ordering, page_index, options)
       _page self.type.page(ordering, page_index, options), ordering, page_index, options
     end

data/lib/bmg/operator.rb

@@ -74,6 +74,7 @@ require_relative 'operator/group'
 require_relative 'operator/image'
 require_relative 'operator/join'
 require_relative 'operator/matching'
+require_relative 'operator/not_matching'
 require_relative 'operator/page'
 require_relative 'operator/project'
 require_relative 'operator/rename'

data/lib/bmg/operator/autowrap.rb

@@ -51,6 +51,17 @@ module Bmg
 
     protected ### optimization
 
+      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?
+          operand.page(ordering, page_index, opts).autowrap(options)
+        else
+          super
+        end
+      end
+
       def _restrict(type, predicate)
         return super unless operand.type.knows_attrlist?
         roots = Support.wrapped_roots(operand.type.to_attrlist, options[:split])

data/lib/bmg/operator/not_matching.rb

@@ -0,0 +1,65 @@
+module Bmg
+  module Operator
+    #
+    # NotMatching operator.
+    #
+    # Filters tuples of left operand to those matching no tuple
+    # in right operand.
+    #
+    class NotMatching
+      include Operator::Binary
+
+      def initialize(type, left, right, on)
+        @type = type
+        @left = left
+        @right = right
+        @on = on
+      end
+
+    private
+
+      attr_reader :on
+
+    public
+
+      def each
+        index = Hash.new
+        right.each_with_object(index) do |t, index|
+          key = tuple_project(t, on)
+          index[key] = true
+        end
+        left.each do |tuple|
+          key = tuple_project(tuple, on)
+          yield tuple unless index.has_key?(key)
+        end
+      end
+
+      def to_ast
+        [ :not_matching, left.to_ast, right.to_ast, on ]
+      end
+
+    protected ### optimization
+
+      def _restrict(type, predicate)
+        # Predicate can always be fully applied to left
+        # It can never be applied on right, unlike matching
+        left
+          .restrict(predicate)
+          .not_matching(right, on)
+      end
+
+    protected ### inspect
+
+      def args
+        [ on ]
+      end
+
+    private
+
+      def tuple_project(tuple, on)
+        TupleAlgebra.project(tuple, on)
+      end
+
+    end # class NotMatching
+  end # module Operator
+end # module Bmg

data/lib/bmg/sql/processor/requalify.rb

@@ -6,7 +6,7 @@ module Bmg
         def initialize(builder)
           super
           @requalify = Hash.new{|h,k|
-            h[k] = Grammar.sexpr [:range_var_name, builder.next_qualifier!]
+            h[k.to_s] = builder.next_qualifier!
           }
         end
         attr_reader :requalify 
@@ -15,7 +15,16 @@ module Bmg
         alias :on_missing :copy_and_apply
 
         def on_range_var_name(sexpr)
-          requalify[sexpr]
+          Grammar.sexpr [:range_var_name, requalify[sexpr.qualifier.to_s] ]
+        end
+
+        def on_where_clause(sexpr)
+          pred = Predicate::Grammar.sexpr(apply(sexpr.predicate))
+          sexpr([:where_clause, pred])
+        end
+
+        def on_qualified_identifier(sexpr)
+          Predicate::Factory.qualified_identifier(requalify[sexpr.qualifier.to_s].to_sym, sexpr.name.to_sym)
         end
 
       end # class Requalify

data/lib/bmg/sql/processor/semi_join.rb

@@ -36,11 +36,13 @@ module Bmg
             commons = self.on
             subquery = Clip.new(commons, false, :star, builder).call(right)
             subquery = Requalify.new(builder).call(subquery)
+            subquery = All.new(builder).call(subquery)
             if commons.size == 0
               builder.exists(subquery)
             elsif commons.size == 1
               identifier = left.desaliaser[commons.to_a.first]
-              Predicate::Factory.in(identifier, subquery)
+              qualified  = Predicate::Factory.qualified_identifier(identifier.qualifier, identifier.as_name)
+              Predicate::Factory.in(qualified, subquery)
             else
               join_pre  = join_predicate(left, subquery, commons)
               subquery  = expand_where_clause(subquery, join_pre)

data/lib/bmg/sql/relation.rb

@@ -58,7 +58,17 @@ module Bmg
       def _matching(type, right, on)
         if right_expr = extract_compatible_sexpr(right)
           expr = before_use(self.expr)
-          expr = Processor::SemiJoin.new(right_expr, on, builder).call(expr)
+          expr = Processor::SemiJoin.new(right_expr, on, false, builder).call(expr)
+          _instance(type, builder, expr)
+        else
+          super
+        end
+      end
+
+      def _not_matching(type, right, on)
+        if right_expr = extract_compatible_sexpr(right)
+          expr = before_use(self.expr)
+          expr = Processor::SemiJoin.new(right_expr, on, true, builder).call(expr)
           _instance(type, builder, expr)
         else
           super

data/lib/bmg/support/keys.rb

@@ -30,7 +30,8 @@ module Bmg
     end
 
     def join(oldtype, newtype, right_type, on)
-      return nil unless rkeys = right_type.keys
+      return nil  unless rkeys = right_type.keys
+      return self if rkeys.any?{|k| (k - on).empty? }
       keys = []
       @keys.each do |k1|
         right_type.keys.each do |k2|

data/lib/bmg/type.rb

@@ -136,6 +136,10 @@ module Bmg
       self
     end
 
+    def not_matching(right, on)
+      self
+    end
+
     def page(ordering, page_size, options)
       self
     end

data/lib/bmg/version.rb

@@ -1,7 +1,7 @@
 module Bmg
   module Version
     MAJOR = 0
-    MINOR = 11
+    MINOR = 12
     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.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Bernard Lambeau
@@ -133,6 +133,7 @@ files:
 - lib/bmg/operator/image.rb
 - lib/bmg/operator/join.rb
 - lib/bmg/operator/matching.rb
+- lib/bmg/operator/not_matching.rb
 - lib/bmg/operator/page.rb
 - lib/bmg/operator/project.rb
 - lib/bmg/operator/rename.rb