bmg 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6eb77419e8fb194a8698e79573474cb8bc54d0ea
-  data.tar.gz: 5036c391503d6706639d9f084f32d0363c8c1658
+  metadata.gz: 31a0ebe96dae3801143c423e0b014bc9dee902b9
+  data.tar.gz: 6c4c003b7af5154301bf64f68f12e2bd7ab880f9
 SHA512:
-  metadata.gz: 55a317e026aad03019afb486e0d06bbf25fc4157b5c8629cd06f183276251a55dbc287a57924a05a55db9f19832a4558ff45ff76a7ca2f053c255e02190d0117
-  data.tar.gz: 5643a05c8dec82c94f49c69e8dfaf34f0a0d75fcf9018eaf1b470d7c3c5e42b83a783f92e89ca4e7241c6afb1ba9d0dafa6aa857dce1378613abac0fdf9273d4
+  metadata.gz: acaf31901fc7b3da45dfce9d7e1e23f1fe4ca86437db8c954538e3817fb4f4297825177ceb77d2fba60afabbb57e199fd0e932b1e944c5a750882c568fe0ea48
+  data.tar.gz: b27cd4e4d9132ac73a5fa27b0e03fa6badd197283b369aab9a463519df3b3f5092e3a669c856528063baa7f2a7eadc98c72aadd2a2a11b40f0a9614f0793c9cf

data/lib/bmg/algebra.rb

@@ -64,6 +64,15 @@ module Bmg
     end
     protected :_image
 
+    def join(right, on = [])
+      _join self.type.join(right.type, on), right, on
+    end
+
+    def _join(type, right, on)
+      Operator::Join.new(type, self, right, on)
+    end
+    protected :_join
+
     def matching(right, on = [])
       _matching self.type.matching(right, on), right, on
     end

data/lib/bmg/algebra/shortcuts.rb

@@ -9,6 +9,22 @@ module Bmg
         self.restrict(predicate)
       end
 
+      def prefix(prefix)
+        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}"
+        }
+        self.rename(renaming)
+      end
+
+      def suffix(suffix)
+        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}"
+        }
+        self.rename(renaming)
+      end
+
     end # module Shortcuts
   end # module Algebra
 end # module Bmg

data/lib/bmg/operator.rb

@@ -72,6 +72,7 @@ require_relative 'operator/constants'
 require_relative 'operator/extend'
 require_relative 'operator/group'
 require_relative 'operator/image'
+require_relative 'operator/join'
 require_relative 'operator/matching'
 require_relative 'operator/page'
 require_relative 'operator/project'

data/lib/bmg/operator/join.rb

@@ -0,0 +1,59 @@
+module Bmg
+  module Operator
+    #
+    # Join operator.
+    #
+    # Natural join, following relational algebra
+    #
+    class Join
+      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] ||= []
+          index[key] << t
+        end
+        left.each do |tuple|
+          key = tuple_project(tuple, on)
+          if to_join = index[key]
+            to_join.each do |right|
+              yield right.merge(tuple)
+            end
+          end
+        end
+      end
+
+      def to_ast
+        [ :join, left.to_ast, right.to_ast, on ]
+      end
+
+    protected ### inspect
+
+      def args
+        [ on ]
+      end
+
+    private
+
+      def tuple_project(tuple, on)
+        TupleAlgebra.project(tuple, on)
+      end
+
+    end # class Join
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/matching.rb

@@ -76,6 +76,6 @@ module Bmg
         TupleAlgebra.project(tuple, on)
       end
 
-    end # class Project
+    end # class Matching
   end # module Operator
 end # module Bmg

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

@@ -4,11 +4,12 @@ module Bmg
       class Join < Processor
         include JoinSupport
 
-        def initialize(right, builder)
+        def initialize(right, on, builder)
           super(builder)
           @right = right
+          @on = on
         end
-        attr_reader :right
+        attr_reader :right, :on
 
         def call(sexpr)
           if unjoinable?(sexpr)
@@ -50,7 +51,7 @@ module Bmg
         end
 
         def join_from_clauses(left, right)
-          joincon = join_predicate(left, right)
+          joincon = join_predicate(left, right, on)
           join = if joincon.tautology?
             [:cross_join, left.table_spec, right.table_spec]
           else

data/lib/bmg/sql/relation.rb

@@ -44,6 +44,17 @@ module Bmg
         _instance(type, builder, expr)
       end
 
+      def _join(type, right, on)
+        if right_expr = extract_compatible_sexpr(right)
+          right_expr = Processor::Requalify.new(builder).call(right_expr)
+          expr = before_use(self.expr)
+          expr = Processor::Join.new(right_expr, on, builder).call(expr)
+          _instance(type, builder, expr)
+        else
+          super
+        end
+      end
+
       def _matching(type, right, on)
         if right_expr = extract_compatible_sexpr(right)
           expr = before_use(self.expr)

data/lib/bmg/support/keys.rb

@@ -15,12 +15,31 @@ module Bmg
       Keys.new(keys, false)
     end
 
+    def autowrap(oldtype, newtype, options)
+      sep = options[:split] || Operator::Autowrap::DEFAULT_OPTIONS[:split]
+      keys = @keys.map{|k|
+        k.map{|a| a.to_s.split(sep).first }.uniq.map(&:to_sym)
+      }
+      Keys.new(keys, false)
+    end
+
     def group(oldtype, newtype, attrs, as)
       keys = [ oldtype.attrlist - attrs ]
       keys += @keys.map{|k| (k & attrs).empty? ? k : (k - attrs) + [as] }
       Keys.new(keys, true)
     end
 
+    def join(oldtype, newtype, right_type, on)
+      return nil unless rkeys = right_type.keys
+      keys = []
+      @keys.each do |k1|
+        right_type.keys.each do |k2|
+          keys << (k1 + k2).uniq
+        end
+      end
+      Keys.new(keys, true)
+    end
+
     def project(oldtype, newtype, attrlist)
       keys = @keys.select{|k| k.all?{|a| attrlist.include?(a) } }
       keys = [newtype.attrlist] if keys.empty?

data/lib/bmg/type.rb

@@ -13,6 +13,12 @@ module Bmg
     attr_accessor :predicate
     protected :predicate=
 
+    def with_predicate(predicate)
+      dup.tap{|x|
+        x.predicate = predicate
+      }
+    end
+
   public ## attrlist
 
     attr_accessor :attrlist
@@ -71,7 +77,15 @@ module Bmg
     end
 
     def autowrap(options)
-      ANY
+      sep = options[:split] || Operator::Autowrap::DEFAULT_OPTIONS[:split]
+      splitter = ->(a){ a.to_s.split(sep).first }
+      is_split = ->(a){ a.to_s.split(sep).size > 1 }
+      dup.tap{|x|
+        x.attrlist  = self.attrlist.map(&splitter).uniq.map(&:to_sym) if knows_attrlist?
+        x.keys      = self._keys.autowrap(self, x, options) if knows_keys?
+        autowrapped = self.predicate.free_variables.select(&is_split)
+        x.predicate = autowrapped.empty? ? self.predicate : self.predicate.and_split(autowrapped).last
+      }
     end
 
     def autosummarize(by, summarization)
@@ -110,6 +124,14 @@ module Bmg
       }
     end
 
+    def join(right, on)
+      dup.tap{|x|
+        x.attrlist  = (knows_attrlist? and right.knows_attrlist?) ? (self.attrlist + right.attrlist).uniq : nil
+        x.predicate = self.predicate & right.predicate
+        x.keys      = (knows_keys? and right.knows_keys?) ? self._keys.join(self, x, right, on) : nil
+      }
+    end
+
     def matching(right, on)
       self
     end

data/lib/bmg/version.rb

@@ -1,8 +1,8 @@
 module Bmg
   module Version
     MAJOR = 0
-    MINOR = 10
-    TINY  = 1
+    MINOR = 11
+    TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Bernard Lambeau
@@ -131,6 +131,7 @@ files:
 - lib/bmg/operator/extend.rb
 - lib/bmg/operator/group.rb
 - lib/bmg/operator/image.rb
+- lib/bmg/operator/join.rb
 - lib/bmg/operator/matching.rb
 - lib/bmg/operator/page.rb
 - lib/bmg/operator/project.rb