bmg 0.18.3 → 0.18.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 340efbb84309b24fd818bd8ff0c0f40b1f2ba3b3f087e3af0ea574fbd1f7c4ef
-  data.tar.gz: d7c6af70390c893f6e198f89a019141b4d5727326183f1663aa7d2e15a7ef694
+  metadata.gz: 9489f2f59b1f3fc644c4a29ee53ba08662f9671ebda9cc6b0340a98c6daf20d9
+  data.tar.gz: f0506ba0dbea31d5d3a1c3f4e3edbdf0ea9ef88e40b386445494f6cd61f759c1
 SHA512:
-  metadata.gz: 69562558e784e35f6c8a81bf8b32f8f1a24bbabc176ca8fc109e8151ad324d15dece34d58cf44196a78387b645ae21ec2cb361cc71e11f93b14fd0c916bd1573
-  data.tar.gz: c25d6966c201c265d2b42dd976e29faf075a8ea285d609883f1f4a9d3c52c941e4c690741e5e277bd4ea8a7d8cfefa4d9adea3a575e2c6006b6993ad767351fb
+  metadata.gz: a3de98440bf031b653d2ef9f7cc6f89ab44969304ca6fdd04cadc514e617a17d5b8b5bfeb791bc03de576acac5431a1d85a52a413f59932aae77ee3f41175ff3
+  data.tar.gz: b583e4ade1f71740afaf2a43c5a0dad8eb27557de533b4cbd61c7f632e79d612a85340897e01ed571a91572acd4f2ab65c00d2b9e00d4d8a8cc8b97919c46102

data/README.md

@@ -234,7 +234,11 @@ t.transform(:to_s)                           # all-attrs transformation
 t.transform(&:to_s)                          # similar, but Proc-driven
 t.transform(:foo => :upcase, ...)            # specific-attrs tranformation
 t.transform([:to_s, :upcase])                # chain-transformation
+r.ungroup([:a, :b, ...])                     # ungroup relation-valued attributes within parent tuple
+r.ungroup(:a)                                # shortcut over ungroup([:a])
 r.union(right)                               # relational union
+r.unwrap([:a, :b, ...])                      # merge tuple-valued attributes within parent tuple
+r.unwrap(:a)                                 # shortcut over unwrap([:a])
 r.where(predicate)                           # alias for restrict(predicate)
 ```
 

data/lib/bmg/algebra.rb

@@ -183,6 +183,15 @@ module Bmg
     end
     protected :_transform
 
+    def ungroup(attrs)
+      _ungroup self.type.ungroup(attrs), attrs
+    end
+
+    def _ungroup(type, attrs)
+      Operator::Ungroup.new(type, self, attrs)
+    end
+    protected :_ungroup
+
     def union(other, options = {})
       return self if other.is_a?(Relation::Empty)
       _union self.type.union(other.type), other, options
@@ -193,6 +202,15 @@ module Bmg
     end
     protected :_union
 
+    def unwrap(attrs)
+      _unwrap self.type.unwrap(attrs), attrs
+    end
+
+    def _unwrap(type, attrs)
+      Operator::Unwrap.new(type, self, attrs)
+    end
+    protected :_unwrap
+
     def spied(spy)
       return self if spy.nil?
       Relation::Spied.new(self, spy)

data/lib/bmg/algebra/shortcuts.rb

@@ -69,6 +69,14 @@ module Bmg
         self.not_matching(right.rename(renaming), on.keys)
       end
 
+      def ungroup(attr)
+        super(attr.is_a?(Symbol) ? [attr] : attr)
+      end
+
+      def unwrap(attr)
+        super(attr.is_a?(Symbol) ? [attr] : attr)
+      end
+
     end # module Shortcuts
   end # module Algebra
 end # module Bmg

data/lib/bmg/error.rb

@@ -16,4 +16,7 @@ module Bmg
   # while unknown
   class UnknownAttributesError < Error; end
 
+  # Raised when an operator is badly used
+  class MisuseError < Error; end
+
 end

data/lib/bmg/operator.rb

@@ -47,4 +47,6 @@ require_relative 'operator/restrict'
 require_relative 'operator/rxmatch'
 require_relative 'operator/summarize'
 require_relative 'operator/transform'
+require_relative 'operator/ungroup'
 require_relative 'operator/union'
+require_relative 'operator/unwrap'

data/lib/bmg/operator/image.rb

@@ -26,7 +26,11 @@ module Bmg
         #   resulting operabds. This option only applies when (optimized) `on`
         #   contains one attribute only. ; it fallbacks on :index_right
         #   otherwise.
-        strategy: :refilter_right
+        strategy: :refilter_right,
+
+        # Whether the attributes on which the join is made should be kept
+        # in the result or not
+        preserve: false
 
       }
 
@@ -96,9 +100,10 @@ module Bmg
 
       def build_right_index(right)
         index = Hash.new{|h,k| h[k] = empty_image }
+        butlist = options[:preserve] ? [] : on
         right.each_with_object(index) do |t, index|
           key = tuple_project(t, on)
-          index[key].operand << tuple_image(t, on)
+          index[key].operand << tuple_allbut(t, butlist)
         end
         if opt = options[:array]
           sorter = to_sorter(opt)
@@ -249,8 +254,8 @@ module Bmg
         TupleAlgebra.project(tuple, on)
       end
 
-      def tuple_image(tuple, on)
-        TupleAlgebra.allbut(tuple, on)
+      def tuple_allbut(tuple, butlist)
+        TupleAlgebra.allbut(tuple, butlist)
       end
 
       def image_type

data/lib/bmg/operator/rename.rb

@@ -31,15 +31,15 @@ module Bmg
       def each
         return to_enum unless block_given?
         @operand.each do |tuple|
-          yield rename(tuple, renaming)
+          yield rename_tuple(tuple, renaming)
         end
       end
 
       def insert(arg)
         case arg
-        when Hash       then operand.insert(rename(arg, reverse_renaming))
+        when Hash       then operand.insert(rename_tuple(arg, reverse_renaming))
         when Relation   then operand.insert(arg.rename(reverse_renaming))
-        when Enumerable then operand.insert(arg.map{|t| rename(t, reverse_renaming) })
+        when Enumerable then operand.insert(arg.map{|t| rename_tuple(t, reverse_renaming) })
         else
           super
         end
@@ -47,7 +47,7 @@ module Bmg
 
       def update(arg)
         case arg
-        when Hash then operand.update(rename(arg, reverse_renaming))
+        when Hash then operand.update(rename_tuple(arg, reverse_renaming))
         else
           super
         end
@@ -89,7 +89,7 @@ module Bmg
 
     private
 
-      def rename(tuple, renaming)
+      def rename_tuple(tuple, renaming)
         tuple.each_with_object({}){|(k,v),h|
           h[renaming[k] || k] = v
           h

data/lib/bmg/operator/ungroup.rb

@@ -0,0 +1,61 @@
+module Bmg
+  module Operator
+    class Ungroup
+      include Operator::Unary
+
+      def initialize(type, operand, attrs)
+        @type = type
+        @operand = operand
+        @attrs = attrs
+      end
+
+    protected
+
+      attr_reader :attrs
+
+    public
+
+      def each(&bl)
+        return to_enum unless block_given?
+        if type.knows_keys? && type.keys.any?{|k| (k & attrs).empty? }
+          operand.each do |tuple|
+            _each(tuple, attrs[0], attrs[1..-1], &bl)
+          end
+        else
+          with_dups = []
+          operand.each do |tuple|
+            _each(tuple, attrs[0], attrs[1..-1]){|t|
+              with_dups << t
+            }
+          end
+          with_dups.uniq.each(&bl)
+        end
+      end
+
+      def _each(tuple, attr, attrs, &bl)
+        rva = tuple[attr] || []
+        rva.each do |rvt|
+          t = tuple.merge(rvt).tap{|t| t.delete(attr) }
+          if attrs.empty?
+            yield(t)
+          else
+            _each(t, attrs[0], attrs[1..-1], &bl)
+          end
+        end
+      end
+
+      def to_ast
+        [ :ungroup, operand.to_ast, attrs ]
+      end
+
+    protected
+
+    protected ### inspect
+
+      def args
+        [ attrs ]
+      end
+
+    end # class Ungroup
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/unwrap.rb

@@ -0,0 +1,47 @@
+module Bmg
+  module Operator
+    class Unwrap
+      include Operator::Unary
+
+      def initialize(type, operand, attrs)
+        @type = type
+        @operand = operand
+        @attrs = attrs
+      end
+
+    protected
+
+      attr_reader :attrs
+
+    public
+
+      def each(&bl)
+        return to_enum unless block_given?
+        operand.each do |tuple|
+          yield tuple_unwrap(tuple)
+        end
+      end
+
+      def to_ast
+        [ :unwrap, operand.to_ast, attrs ]
+      end
+
+    protected
+
+      def tuple_unwrap(tuple)
+        attrs.inject(tuple.dup){|t,attr|
+          t.merge(tuple[attr]).tap{|t2|
+            t2.delete(attr)
+          }
+        }
+      end
+
+    protected ### inspect
+
+      def args
+        [ attrs ]
+      end
+
+    end # class Unwrap
+  end # module Operator
+end # module Bmg

data/lib/bmg/reader/csv.rb

@@ -23,7 +23,7 @@ module Bmg
         return to_enum unless block_given?
         require 'csv'
         with_io do |io|
-          ::CSV.new(io, csv_options).each do |row|
+          ::CSV.new(io, **csv_options).each do |row|
             yield tuple(row)
           end
         end

data/lib/bmg/reader/excel.rb

@@ -25,7 +25,7 @@ module Bmg
           .each_with_index
           .each do |row, i|
             if i==0
-              headers = row.map(&:to_sym)
+              headers = row.map{|c| c.to_s.strip.to_sym }
             else
               init = init_tuple(i)
               tuple = (0...headers.size)

data/lib/bmg/sequel/translator.rb

@@ -78,16 +78,29 @@ module Bmg
       end
 
       def on_func_call(sexpr)
-        args = sexpr.func_args.map{|fa| apply(fa) }
-        ::Sequel.function(sexpr.func_name, *args)
+        case sexpr.func_name
+        when :cast
+          to_cast = apply(sexpr.func_args.first)
+          type = sexpr.func_args.last.last
+          to_cast.cast(type)
+        else
+          args = sexpr.func_args.map{|fa| apply(fa) }
+          ::Sequel.function(sexpr.func_name, *args)
+        end
       end
 
       def on_summarizer(sexpr)
-        if sexpr.summary_expr
-          ::Sequel.function(sexpr.summary_func, apply(sexpr.summary_expr))
+        func, distinct = if sexpr.summary_func == :distinct_count
+          [:count, true]
+        else
+          [sexpr.summary_func, false]
+        end
+        f = if sexpr.summary_expr
+          ::Sequel.function(func, apply(sexpr.summary_expr))
         else
-          ::Sequel.function(sexpr.summary_func).*
+          ::Sequel.function(func).*
         end
+        distinct ? f.distinct : f
       end
 
       def on_qualified_name(sexpr)

data/lib/bmg/sql.rb

@@ -2,7 +2,10 @@ require 'sexpr'
 module Bmg
 
   module Sql
-  end
+
+    class NotSupportedError < Bmg::Error; end
+
+  end # module Sql
 
   def sql(table, type = Type::ANY)
     builder = Sql::Builder.new

data/lib/bmg/sql/processor.rb

@@ -85,4 +85,5 @@ require_relative 'processor/semi_join'
 require_relative 'processor/flatten'
 require_relative 'processor/requalify'
 require_relative 'processor/summarize'
+require_relative 'processor/transform'
 require_relative 'processor/bind'

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

@@ -36,10 +36,10 @@ module Bmg
             [:select_item,
               [ :summarizer,
                 summarizer.to_summarizer_name,
-                sexpr.desaliaser[attr] ],
+                sexpr.desaliaser[summarizer.functor] ],
               [:column_name, attr.to_s] ]
           }
-          [:select_list] + by_list + group_list
+          ([:select_list] + by_list + group_list)
         end
 
       end # class Summarize

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

@@ -0,0 +1,105 @@
+module Bmg
+  module Sql
+    class Processor
+      class Transform < Processor
+
+        module SplitSupported
+          extend(self)
+
+          def split_supported(tr, &bl)
+            case tr
+            when Array
+              i = tr.find_index{|x| !bl.call(x) } || tr.size
+              [tr[0...i], tr[i..-1]].map{|a|
+                case a.size
+                when 0 then nil
+                when 1 then a.first
+                else a
+                end
+              }
+            when Hash
+              tr.inject([{}, {}]){|(sup,unsup),(k,v)|
+                mine, hers = _split_supported(v, &bl)
+                [
+                  sup.merge(k => mine),
+                  unsup.merge(k => hers)
+                ].map(&:compact)
+              }.map{|h| h.empty? ? nil : h }
+            else
+              _split_supported(tr, &bl)
+            end
+          end
+
+          def _split_supported(tr, &bl)
+            if tr.is_a?(Array)
+              split_supported(tr, &bl)
+            else
+              bl.call(tr) ? [tr, nil] : [nil, tr]
+            end
+          end
+        end # module SplitSupported
+
+        def initialize(transformation, options, builder)
+          raise NotSupportedError unless options.empty?
+          super(builder)
+          @transformation = transformation
+        end
+        attr_reader :transformation
+
+        def self.split_supported(*args, &bl)
+          SplitSupported.split_supported(*args, &bl)
+        end
+
+        def on_select_list(sexpr)
+          sexpr.each_with_index.map{|child,index|
+            index == 0 ? child : apply(child)
+          }
+        end
+
+        def on_select_item(sexpr)
+          as = sexpr.as_name.to_sym
+          case t = transformation_for(as)
+          when NilClass
+            sexpr
+          when Class, Array
+            sexpr([:select_item,
+              func_call_node(sexpr, Array(t).reverse),
+              sexpr[2]
+            ])
+          else
+            raise NotSupportedError
+          end
+        end
+
+      private
+
+        def func_call_node(sexpr, ts)
+          _func_call_node(sexpr, ts.first, ts[1..-1])
+        end
+
+        def _func_call_node(sexpr, head, tail)
+          inside = if tail.empty?
+            sexpr[1]
+          else
+            _func_call_node(sexpr, tail.first, tail[1..-1])
+          end
+          [:func_call,
+            :cast,
+            inside,
+            [ :literal, head ] ]
+        end
+
+        def transformation_for(as)
+          case t = transformation
+          when Class then t
+          when Hash  then t[as]
+          when Array then t
+          else
+            raise Sql::NotSupportedError, "Unable to use `#{as}` for `transform`"
+          end
+        end
+
+      end # class Transform
+    end # class Processor
+  end # module Sql
+end # module Bmg

data/lib/bmg/sql/relation.rb

@@ -123,13 +123,13 @@ module Bmg
 
       def _rename(type, renaming)
         expr = before_use(self.expr)
-        expr = Processor::Rename.new(renaming, builder).call(self.expr)
+        expr = Processor::Rename.new(renaming, builder).call(expr)
         _instance(type, builder, expr)
       end
 
       def _restrict(type, predicate)
         expr = before_use(self.expr)
-        expr = Processor::Where.new(predicate, builder).call(self.expr)
+        expr = Processor::Where.new(predicate, builder).call(expr)
         _instance(type, builder, expr)
       end
 
@@ -137,23 +137,37 @@ module Bmg
         summarization = ::Bmg::Summarizer.summarization(defs)
         if can_compile_summarization?(summarization)
           expr = before_use(self.expr)
-          expr = Processor::Summarize.new(by, summarization, builder).call(self.expr)
+          expr = Processor::Summarize.new(by, summarization, builder).call(expr)
           _instance(type, builder, expr)
         else
           super
         end
       end
 
+      def _transform(type, transformation, options)
+        expr = before_use(self.expr)
+        sup, unsup = Processor::Transform.split_supported(transformation){|x|
+          [String, Integer, Float, Date, DateTime].include?(x)
+        }
+        return super if sup.nil?
+        expr = Processor::Transform.new(sup, options, builder).call(expr)
+        result = _instance(type, builder, expr)
+        result = result.transform(unsup, options) if unsup
+        result
+      rescue Sql::NotSupportedError
+        super
+      end
+
       def can_compile_summarization?(summarization)
         summarization.values.all?{|s|
-          [:avg, :count, :max, :min, :sum].include?(s.to_summarizer_name)
+          [:avg, :count, :max, :min, :sum, :distinct_count].include?(s.to_summarizer_name)
         }
       end
 
       def _union(type, right, options)
         if right_expr = extract_compatible_sexpr(right)
           expr = before_use(self.expr)
-          expr = Processor::Merge.new(:union, !!options[:all], right_expr, builder).call(self.expr)
+          expr = Processor::Merge.new(:union, !!options[:all], right_expr, builder).call(expr)
           _instance(type, builder, expr)
         else
           super

data/lib/bmg/summarizer.rb

@@ -95,16 +95,7 @@ module Bmg
     # @param the current iterated tuple
     # @return updated memo value
     def happens(memo, tuple)
-      value = case @functor
-      when Proc
-        @functor.call(tuple)
-      when NilClass
-        tuple
-      when Symbol
-        tuple[@functor]
-      else
-        tuple[@functor]
-      end
+      value = extract_value(tuple)
       _happens(memo, value)
     end
 
@@ -140,7 +131,25 @@ module Bmg
 
     # Returns the canonical summarizer name
     def to_summarizer_name
-      self.class.name.downcase[/::([a-z]+)$/, 1].to_sym
+      self.class.name
+        .gsub(/[a-z][A-Z]/){|x| x.split('').join('_') }
+        .downcase[/::([a-z_]+)$/, 1]
+        .to_sym
+    end
+
+  protected
+
+    def extract_value(tuple)
+      value = case @functor
+      when Proc
+        @functor.call(tuple)
+      when NilClass
+        tuple
+      when Symbol
+        tuple[@functor]
+      else
+        tuple[@functor]
+      end
     end
 
   end # class Summarizer
@@ -155,6 +164,8 @@ require_relative 'summarizer/stddev'
 require_relative 'summarizer/percentile'
 require_relative 'summarizer/collect'
 require_relative 'summarizer/distinct'
+require_relative 'summarizer/distinct_count'
 require_relative 'summarizer/concat'
 require_relative 'summarizer/by_proc'
 require_relative 'summarizer/multiple'
+require_relative 'summarizer/value_by'

data/lib/bmg/summarizer/by_proc.rb

@@ -16,7 +16,7 @@ module Bmg
       end
 
       # Returns [] as least value.
-      def least()
+      def least
         @least
       end
 

data/lib/bmg/summarizer/distinct_count.rb

@@ -0,0 +1,36 @@
+module Bmg
+  class Summarizer
+    #
+    # Collect the count of distinct values.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.distinct_count(:qty).summarize(...)
+    #
+    class DistinctCount < Summarizer
+
+      # Returns [] as least value.
+      def least()
+        {}
+      end
+
+      # Adds val to the memo array
+      def _happens(memo, val)
+        memo[val] = true
+        memo
+      end
+
+      def finalize(memo)
+        memo.keys.size
+      end
+
+    end # class DistinctCount
+
+    # Factors a distinct count summarizer
+    def self.distinct_count(*args, &bl)
+      DistinctCount.new(*args, &bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/percentile.rb

@@ -10,10 +10,17 @@ module Bmg
     #
     class Percentile < Summarizer
 
-      def initialize(attribute = nil, nth = 50, &bl)
-        attribute, nth = nil, attribute if attribute.is_a?(Integer)
-        super(*[attribute].compact, &bl)
-        @nth = nth
+      DEFAULT_OPTIONS = {
+        :variant => :continuous
+      }
+
+      def initialize(*args, &bl)
+        @nth = args.find{|a| a.is_a?(Integer) } || 50
+        functor = args.find{|a| a.is_a?(Symbol) } || bl
+        options = args.select{|a| a.is_a?(Hash) }.inject(DEFAULT_OPTIONS){|memo,opts|
+          memo.merge(opts)
+        }.dup
+        super(functor, options)
       end
 
       # Returns [] as least value.
@@ -29,19 +36,44 @@ module Bmg
       # Finalizes the computation.
       def finalize(memo)
         return nil if memo.empty?
-        index = memo.size * (@nth / 100.0)
-        above = [[index.ceil - 1, memo.size - 1].min, 0].max
-        below = [index.floor - 1, 0].max
+        index = memo.size.to_f * (@nth.to_f / 100.0)
+        floor, ceil = index.floor, index.ceil
+        ceil +=1 if floor == ceil
+        below = [floor - 1, 0].max
+        above = [[ceil - 1, memo.size - 1].min, 0].max
         sorted = memo.sort
-        (sorted[above] + sorted[below]) / 2
+        if options[:variant] == :continuous
+          (sorted[above] + sorted[below]) / 2.0
+        else
+          sorted[below]
+        end
       end
 
     end # class Avg
 
-    # Factors an average summarizer
     def self.percentile(*args, &bl)
       Percentile.new(*args, &bl)
     end
 
+    def self.percentile_cont(*args, &bl)
+      Percentile.new(*(args + [{:variant => :continuous}]), &bl)
+    end
+
+    def self.percentile_disc(*args, &bl)
+      Percentile.new(*(args + [{:variant => :discrete}]), &bl)
+    end
+
+    def self.median(*args, &bl)
+      Percentile.new(*(args + [50]), &bl)
+    end
+
+    def self.median_cont(*args, &bl)
+      Percentile.new(*(args + [50, {:variant => :continuous}]), &bl)
+    end
+
+    def self.median_disc(*args, &bl)
+      Percentile.new(*(args + [50, {:variant => :discrete}]), &bl)
+    end
+
   end # class Summarizer
 end # module Bmg

data/lib/bmg/summarizer/value_by.rb

@@ -0,0 +1,62 @@
+module Bmg
+  class Summarizer
+    #
+    # ValueBy summarizer.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.value_by(:qty, :by => :serie).summarize(...)
+    #
+    class ValueBy < Summarizer
+
+      DEFAULT_OPTIONS = {
+        :symbolize => false
+      }
+
+      # Returns {} as least value.
+      def least
+        {}
+      end
+
+      # Collects the value
+      def happens(memo, tuple)
+        by = tuple[options[:by]]
+        by = by.to_sym if by && options[:symbolize]
+        misuse!(tuple, memo) if memo.has_key?(by)
+        memo.tap{|m|
+          m[by] = extract_value(tuple)
+        }
+      end
+
+      # Finalizes the computation.
+      def finalize(memo)
+        default_tuple.merge(memo)
+      end
+
+    private
+
+      def default_tuple
+        (options[:series] || []).each_with_object({}){|s,ss|
+          s_def = options[:default]
+          s = s.to_sym if s && options[:symbolize]
+          ss[s] = s_def
+        }
+      end
+
+      def misuse!(tuple, memo)
+        msg = "Summarizer.value_by: summarization key + the serie must form be a candidate key"
+        msg += "\n"
+        msg += "  Tuple: #{tuple.inspect}"
+        msg += "  Memo:  #{memo.inspect}"
+        raise MisuseError, msg
+      end
+
+    end # class ValueBy
+
+    def self.value_by(*args, &bl)
+      ValueBy.new(*args, &bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/support/keys.rb

@@ -69,6 +69,11 @@ module Bmg
       Keys.new(shared, false)
     end
 
+    def unwrap(oldtype, newtype, attrs)
+      untouched = @keys.select{|k| (attrs & k).empty? }
+      Keys.new(untouched, false)
+    end
+
   public ## usuals
 
     def to_a

data/lib/bmg/support/tuple_transformer.rb

@@ -32,7 +32,16 @@ module Bmg
           }
         when Hash
           with.each_with_object(tuple.dup){|(k,v),dup|
-            dup[k] = transform_attr(dup[k], v)
+            case k
+            when Symbol
+              dup[k] = transform_attr(dup[k], v)
+            when Class
+              dup.keys.each do |attrname|
+                dup[attrname] = transform_attr(dup[attrname], v) if dup[attrname].is_a?(k)
+              end
+            else
+              raise ArgumentError, "Unexpected transformation `#{with.inspect}`"
+            end
           }
         when Array
           with.inject(tuple){|dup,on|
@@ -50,6 +59,19 @@ module Bmg
         when Regexp
           m = with.match(value.to_s)
           m.nil? ? m : m.to_s
+        when Class
+          return value if value.nil?
+          if with.respond_to?(:parse)
+            with.parse(value)
+          elsif with == Integer
+            Integer(value)
+          elsif with == Float
+            Float(value)
+          elsif with == String
+            value.to_s
+          else
+            raise ArgumentError, "#{with} should respond to `parse`"
+          end
         when Proc
           with.call(value)
         when Hash

data/lib/bmg/type.rb

@@ -82,7 +82,7 @@ module Bmg
 
     def with_keys(keys)
       dup.tap{|x|
-        x.keys = Keys.new(keys)
+        x.keys = keys ? Keys.new(keys) : nil
       }
     end
 
@@ -266,6 +266,15 @@ module Bmg
       }
     end
 
+    def ungroup(attrlist)
+      known_attributes!(attrlist) if typechecked? && knows_attrlist?
+      dup.tap{|x|
+        x.attrlist  = nil
+        x.predicate = Predicate.tautology
+        x.keys      = nil
+      }
+    end
+
     def union(other)
       if typechecked? && knows_attrlist? && other.knows_attrlist?
         missing = self.attrlist - other.attrlist
@@ -280,6 +289,15 @@ module Bmg
       }
     end
 
+    def unwrap(attrlist)
+      known_attributes!(attrlist) if typechecked? && knows_attrlist?
+      dup.tap{|x|
+        x.attrlist  = nil
+        x.predicate = predicate.and_split(attrlist).last
+        x.keys      = self._keys.unwrap(self, x, attrlist) if knows_keys?
+      }
+    end
+
   private
 
     def known_attributes!(attrs)

data/lib/bmg/version.rb

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

data/lib/bmg/writer/csv.rb

@@ -19,7 +19,8 @@ module Bmg
         relation.each do |tuple|
           if csv.nil?
             headers = infer_headers(tuple) if headers.nil?
-            csv = CSV.new(string_or_io, csv_options.merge(headers: headers))
+            csv_opts = csv_options.merge(headers: headers)
+            csv = CSV.new(string_or_io, **csv_opts)
           end
           csv << headers.map{|h| tuple[h] }
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.18.8
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-06 00:00:00.000000000 Z
+date: 2021-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -164,7 +164,9 @@ files:
 - lib/bmg/operator/shared/unary.rb
 - lib/bmg/operator/summarize.rb
 - lib/bmg/operator/transform.rb
+- lib/bmg/operator/ungroup.rb
 - lib/bmg/operator/union.rb
+- lib/bmg/operator/unwrap.rb
 - lib/bmg/reader.rb
 - lib/bmg/reader/csv.rb
 - lib/bmg/reader/excel.rb
@@ -259,6 +261,7 @@ files:
 - lib/bmg/sql/processor/semi_join.rb
 - lib/bmg/sql/processor/star.rb
 - lib/bmg/sql/processor/summarize.rb
+- lib/bmg/sql/processor/transform.rb
 - lib/bmg/sql/processor/where.rb
 - lib/bmg/sql/relation.rb
 - lib/bmg/sql/support/from_clause_orderer.rb
@@ -270,12 +273,14 @@ files:
 - lib/bmg/summarizer/concat.rb
 - lib/bmg/summarizer/count.rb
 - lib/bmg/summarizer/distinct.rb
+- lib/bmg/summarizer/distinct_count.rb
 - lib/bmg/summarizer/max.rb
 - lib/bmg/summarizer/min.rb
 - lib/bmg/summarizer/multiple.rb
 - lib/bmg/summarizer/percentile.rb
 - lib/bmg/summarizer/stddev.rb
 - lib/bmg/summarizer/sum.rb
+- lib/bmg/summarizer/value_by.rb
 - lib/bmg/summarizer/variance.rb
 - lib/bmg/support.rb
 - lib/bmg/support/keys.rb