bmg 0.18.5 → 0.18.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6569e9038c83dda887da734d97ef58f9ff6e94984c78e8eae993561cde3bbfcc
-  data.tar.gz: 85d65ca717992a132e94ae17dbdf2cc671a161c495eb5be240c3d4e342e90c3f
+  metadata.gz: e287adcc94d2a0a5a88604e90cb34895ff801b137478c3cfa8b32d2093e7289c
+  data.tar.gz: 148775b4bdfbcb45099ed2587268243eef46b8a214d9bbf5f9f3abc9960764f2
 SHA512:
-  metadata.gz: fbeb5215e5942626dd5115d95c091602daa57128014bc0833c38c3460697ef9dbc59b4ccd7566d4d3604e8d7a8c5e7e4812159a5bb89d3dad477e6a7b75545d8
-  data.tar.gz: 9e8a9eaaf3699d28890cb15faef5b12360f9bf26c5bb0e9bf42ccedba0b7b5a3c8c2eb627f8b1a4e154c8d992426f47ed82153e9f110634f0ba6aa7ceddd1353
+  metadata.gz: ae86583f677f487bb3b6e71fa1a5ed07cc731bd927cf74716d68818d330809f86aaddb98c8a8c9848f68c3b0a8ba183996029ecf745db377d740b1c4da59b995
+  data.tar.gz: a0fca7d1f3fa2ecc8097a0167d5ec9767a047b61af54212b16030dfe23a46c05e3597641c0c125c40f0652fbdc15d593e7201cc9b430467e90216af0630e4c5d

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/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/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/operator/autowrap.rb

@@ -22,6 +22,7 @@ module Bmg
 
       DEFAULT_OPTIONS = {
         :postprocessor => :none,
+        :postprocessor_condition => :all,
         :split => "_"
       }
 
@@ -167,7 +168,7 @@ module Bmg
 
       def normalize_options(options)
         opts = DEFAULT_OPTIONS.merge(options)
-        opts[:postprocessor] = NoLeftJoinNoise.new(opts[:postprocessor])
+        opts[:postprocessor] = NoLeftJoinNoise.new(opts[:postprocessor], opts[:postprocessor_condition])
         opts
       end
 
@@ -209,17 +210,17 @@ module Bmg
       class NoLeftJoinNoise
 
         REMOVERS = {
-          nil:    ->(t,k){ t[k] = nil  },
-          delete: ->(t,k){ t.delete(k) },
-          none:   ->(t,k){ t           }
+          nil:       ->(t,k){ t[k] = nil  },
+          delete:    ->(t,k){ t.delete(k) },
+          none:      ->(t,k){ t           }
         }
 
-        def self.new(remover)
+        def self.new(remover, remover_condition = :all)
           return remover if remover.is_a?(NoLeftJoinNoise)
           super
         end
 
-        def initialize(remover)
+        def initialize(remover, remover_condition = :all)
           @remover_to_s = remover
           @remover = case remover
           when NilClass then REMOVERS[:none]
@@ -229,22 +230,35 @@ module Bmg
           else
             raise "Invalid remover `#{remover}`"
           end
+          @remover_condition = case remover_condition
+          when :all then ->(tuple){ all_nil?(tuple) }
+          when :id  then ->(tuple){ id_nil?(tuple) }
+          else
+            raise "Invalid remover condition `#{remover_condition}`"
+          end
         end
         attr_reader :remover
 
         def call(tuple)
           tuple.each_key do |k|
             call(tuple[k]) if tuple[k].is_a?(Hash)
-            @remover.call(tuple, k) if tuple[k].is_a?(Hash) && all_nil?(tuple[k])
+            @remover.call(tuple, k) if tuple[k].is_a?(Hash) && @remover_condition.call(tuple[k])
           end
           tuple
         end
 
         def all_nil?(tuple)
           return false unless tuple.is_a?(Hash)
+
           tuple.all?{|(k,v)| v.nil? || all_nil?(tuple[k]) }
         end
 
+        def id_nil?(tuple)
+          return false unless tuple.is_a?(Hash)
+
+          tuple[:id].nil?
+        end
+
         def inspect
           @remover_to_s.inspect
         end

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/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/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/reader/excel.rb

@@ -4,6 +4,7 @@ module Bmg
       include Reader
 
       DEFAULT_OPTIONS = {
+        sheet: 0,
         skip: 0,
         row_num: true
       }
@@ -19,7 +20,7 @@ module Bmg
         require 'roo'
         xlsx = Roo::Spreadsheet.open(@path, @options)
         headers = nil
-        xlsx.sheet(0)
+        xlsx.sheet(@options[:sheet])
           .each
           .drop(@options[:skip])
           .each_with_index

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/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/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/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/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/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/first.rb

@@ -0,0 +1,25 @@
+module Bmg
+  class Summarizer
+    #
+    # First summarizer.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.first(:qty, :order => [:id]).summarize(...)
+    #
+    class First < Positional
+
+      def choose(t1, t2)
+        t1
+      end
+
+    end # class First
+
+    # Factors a first summarizer
+    def self.first(*args, &bl)
+      First.new(*args, &bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/last.rb

@@ -0,0 +1,25 @@
+module Bmg
+  class Summarizer
+    #
+    # Last summarizer.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.last(:qty, :order => [:id]).summarize(...)
+    #
+    class Last < Positional
+
+      def choose(t1, t2)
+        t2
+      end
+
+    end # class Last
+
+    # Factors a last summarizer
+    def self.last(*args, &bl)
+      Last.new(*args, &bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/positional.rb

@@ -0,0 +1,33 @@
+module Bmg
+  class Summarizer
+    # See First and Last
+    class Positional < Summarizer
+
+      def initialize(*args, &block)
+        super
+        raise ArgumentError, "Missing order" unless options[:order]
+        @ordering = Ordering.new(options[:order])
+      end
+      attr_reader :ordering
+
+      def least
+        nil
+      end
+
+      def happens(memo, tuple)
+        if memo.nil?
+          tuple
+        else
+          c = ordering.call(memo, tuple)
+          c <= 0 ? choose(memo, tuple) : choose(tuple, memo)
+        end
+      end
+
+      def finalize(memo)
+        return nil if memo.nil?
+        extract_value(memo)
+      end
+
+    end # class Positional
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/value_by.rb

@@ -39,7 +39,7 @@ module Bmg
       def default_tuple
         (options[:series] || []).each_with_object({}){|s,ss|
           s_def = options[:default]
-          s_def = s_def.to_sym if s_def && options[:symbolize]
+          s = s.to_sym if s && options[:symbolize]
           ss[s] = s_def
         }
       end

data/lib/bmg/summarizer.rb

@@ -131,7 +131,10 @@ 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
@@ -161,7 +164,11 @@ 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'
+require_relative 'summarizer/positional'
+require_relative 'summarizer/first'
+require_relative 'summarizer/last'

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/ordering.rb

@@ -6,8 +6,12 @@ module Bmg
     end
     attr_reader :attrs
 
+    def call(t1, t2)
+      comparator.call(t1, t2)
+    end
+
     def comparator
-      ->(t1, t2) {
+      @comparator ||= ->(t1, t2) {
         attrs.each do |(attr,direction)|
           c = t1[attr] <=> t2[attr]
           return (direction == :desc ? -c : c) unless c==0

data/lib/bmg/support/tuple_transformer.rb

@@ -59,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  = 5
+    TINY  = 9
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

metadata

@@ -1,35 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.18.5
+  version: 0.18.9
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-08 00:00:00.000000000 Z
+date: 2021-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.5.0
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.5.0
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: path
   requirement: !ruby/object:Gem::Requirement
@@ -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,10 +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/first.rb
+- lib/bmg/summarizer/last.rb
 - lib/bmg/summarizer/max.rb
 - lib/bmg/summarizer/min.rb
 - lib/bmg/summarizer/multiple.rb
 - lib/bmg/summarizer/percentile.rb
+- lib/bmg/summarizer/positional.rb
 - lib/bmg/summarizer/stddev.rb
 - lib/bmg/summarizer/sum.rb
 - lib/bmg/summarizer/value_by.rb
@@ -310,7 +317,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Bmg is Alf's successor.