bmg 0.17.5 → 0.18.1

data/lib/bmg/operator.rb

@@ -46,4 +46,5 @@ require_relative 'operator/rename'
 require_relative 'operator/restrict'
 require_relative 'operator/rxmatch'
 require_relative 'operator/summarize'
+require_relative 'operator/transform'
 require_relative 'operator/union'

data/lib/bmg/operator/allbut.rb

@@ -63,12 +63,34 @@ module Bmg
 
     protected ### optimization
 
+      def _allbut(type, butlist)
+        operand.allbut(self.butlist|butlist)
+      end
+
+      def _matching(type, right, on)
+        # Always possible to push the matching, since by construction
+        # `on` can only use attributes that have not been trown away,
+        # hence they exist on `operand` too.
+        operand.matching(right, on).allbut(butlist)
+      end
+
       def _restrict(type, predicate)
         operand.restrict(predicate).allbut(butlist)
       end
 
+      def _page(type, ordering, page_index, options)
+        return super unless self.preserving_key?
+        operand.page(ordering, page_index, options).allbut(butlist)
+      end
+
     protected ### inspect
 
+      def preserving_key?
+        operand.type.knows_keys? && operand.type.keys.find{|k|
+          (k & butlist).empty?
+        }
+      end
+
       def args
         [ butlist ]
       end

data/lib/bmg/operator/autosummarize.rb

@@ -24,6 +24,22 @@ 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)
         h = {}
         @operand.each do |tuple|
@@ -175,11 +191,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 +227,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

@@ -86,6 +86,14 @@ module Bmg
         false
       end
 
+      def _matching(type, right, on)
+        if (wrapped_roots! & on).empty?
+          operand.matching(right, on).autowrap(options)
+        else
+          super
+        end
+      end
+
       def _page(type, ordering, page_index, opts)
         attrs = ordering.map{|(a,d)| a }
         if (wrapped_roots! & attrs).empty?

data/lib/bmg/operator/image.rb

@@ -99,9 +99,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
@@ -156,6 +157,24 @@ module Bmg
 
     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
@@ -227,6 +246,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/page.rb

@@ -45,13 +45,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/transform.rb

@@ -0,0 +1,94 @@
+module Bmg
+  module Operator
+    #
+    # Transform operator.
+    #
+    # Transforms existing attributes through computations
+    #
+    # Example:
+    #
+    #   [{ a: 1 }] transform { a: ->(t){ t[:a]*2 } } => [{ a: 4 }]
+    #
+    class Transform
+      include Operator::Unary
+
+      DEFAULT_OPTIONS = {}
+
+      def initialize(type, operand, transformation, options = {})
+        @type = type
+        @operand = operand
+        @transformation = transformation
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+    protected
+
+      attr_reader :transformation, :options
+
+    public
+
+      def each
+        t = transformer
+        @operand.each do |tuple|
+          yield t.call(tuple)
+        end
+      end
+
+      def to_ast
+        [ :transform, operand.to_ast, transformation.dup ]
+      end
+
+    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
+        [ transformation ]
+      end
+
+    private
+
+      def transformer
+        @transformer ||= TupleTransformer.new(transformation)
+      end
+
+    end # class Transform
+  end # module Operator
+end # module Bmg

data/lib/bmg/reader.rb

@@ -9,3 +9,4 @@ module Bmg
 end
 require_relative "reader/csv"
 require_relative "reader/excel"
+require_relative "reader/text_file"

data/lib/bmg/reader/text_file.rb

@@ -0,0 +1,56 @@
+module Bmg
+  module Reader
+    class TextFile
+      include Reader
+
+      DEFAULT_OPTIONS = {
+        strip: true,
+        parse: nil
+      }
+
+      def initialize(type, path, options = {})
+        options = { parse: options } if options.is_a?(Regexp)
+        @path = path
+        @options = DEFAULT_OPTIONS.merge(options)
+        @type = infer_type(type)
+      end
+      attr_reader :path, :options
+
+    public # Relation
+
+      def each
+        path.each_line.each_with_index do |text, line|
+          text = text.strip if strip?
+          parsed = parse(text)
+          yield({line: 1+line}.merge(parsed)) if parsed
+        end
+      end
+
+    private
+
+      def infer_type(base)
+        return base unless base == Bmg::Type::ANY
+        attr_list = if rx = options[:parse]
+          [:line] + rx.names.map(&:to_sym)
+        else
+          [:line, :text]
+        end
+        base
+          .with_attrlist(attr_list)
+          .with_keys([[:line]])
+      end
+
+      def strip?
+        options[:strip]
+      end
+
+      def parse(text)
+        return { text: text } unless rx = options[:parse]
+        if match = rx.match(text)
+          TupleAlgebra.symbolize_keys(match.named_captures)
+        end
+      end
+
+    end # class TextFile
+  end # module Reader
+end # module Bmg

data/lib/bmg/relation.rb

@@ -17,6 +17,16 @@ module Bmg
       self
     end
 
+    def type
+      Bmg::Type::ANY
+    end
+
+    def with_type(type)
+      dup.tap{|r|
+        r.type = type
+      }
+    end
+
     def with_typecheck
       dup.tap{|r|
         r.type = r.type.with_typecheck
@@ -113,9 +123,10 @@ module Bmg
     # When no string_or_io is used, the method uses a string.
     #
     # The method always returns the string_or_io.
-    def to_csv(options = {}, string_or_io = nil)
+    def to_csv(options = {}, string_or_io = nil, preferences = nil)
       options, string_or_io = {}, options unless options.is_a?(Hash)
-      Writer::Csv.new(options).call(self, string_or_io)
+      string_or_io, preferences = nil, string_or_io if string_or_io.is_a?(Hash)
+      Writer::Csv.new(options, preferences).call(self, string_or_io)
     end
 
     # Converts to an sexpr expression.

data/lib/bmg/relation/proxy.rb

@@ -0,0 +1,63 @@
+module Bmg
+  module Relation
+    #
+    # This module can be used to create typed collection on top
+    # of Bmg relations. Algebra methods will be delegated to the
+    # decorated relation, and results wrapped in a new instance
+    # of the class.
+    #
+    module Proxy
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def method_missing(name, *args, &bl)
+        if @relation.respond_to?(name)
+          res = @relation.send(name, *args, &bl)
+          res.is_a?(Relation) ? _proxy(res) : res
+        else
+          super
+        end
+      end
+
+      def respond_to?(name, *args)
+        @relation.respond_to?(name) || super
+      end
+
+      [
+        :extend
+      ].each do |name|
+        define_method(name) do |*args, &bl|
+          res = @relation.send(name, *args, &bl)
+          res.is_a?(Relation) ? _proxy(res) : res
+        end
+      end
+
+      [
+        :one,
+        :one_or_nil
+      ].each do |meth|
+        define_method(meth) do |*args, &bl|
+          res = @relation.send(meth, *args, &bl)
+          res.nil? ? nil : _proxy_tuple(res)
+        end
+      end
+
+      def to_json(*args, &bl)
+        @relation.to_json(*args, &bl)
+      end
+
+    protected
+
+      def _proxy(relation)
+        self.class.new(relation)
+      end
+
+      def _proxy_tuple(tuple)
+        tuple
+      end
+
+    end # module Proxy
+  end # class Relation
+end # module Bmg

data/lib/bmg/relation/spied.rb

@@ -24,7 +24,7 @@ module Bmg
       protected :type=
 
       def each(&bl)
-        spy.call(self)
+        spy.call(self) if bl
         operand.each(&bl)
       end
 

data/lib/bmg/sql/relation.rb

@@ -10,7 +10,6 @@ module Bmg
       end
 
       attr_accessor :type
-      protected :type=
 
     protected