bmg 0.18.6 → 0.18.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 482e0bb06c06e4afc620696491cf75f788902240c75f9c82d71ce9b0db4deee1
-  data.tar.gz: f49609c7cf929149d91bb1c29703fd4e5fb7d861073b38ad916a851214ec20b9
+SHA1:
+  metadata.gz: 8b2c8128cd4f8a2dad6d605f518cc9c0c8d40060
+  data.tar.gz: 9560e2261e1c0abb410ef9311b003c26fa347f16
 SHA512:
-  metadata.gz: a4068309c373faa50bfc4549648ee26e3220187192a529ee8c6c890424c52b4d05103c2ebf7b137354c1c8a82a756eafbdb5c6b266f489c3c6e0a0b9923a4d15
-  data.tar.gz: ba7a0046919e2d796c58cae326f3d4cf7b86f6d577e34f79395c04286c4bf463cb4c349cb2a5ce4611fbd6e310ebf521736fb190bcc1d1c2c42c51ccc175fb2e
+  metadata.gz: 4dbdd828629da347e11df110e15d0970e1f0862825ac0182a670cd0ff5fd8fb5a9e9e4eea11d3a761e264513227eacd5aa7cb9f2f3a609557c93a0ba3fb8b5cc
+  data.tar.gz: c5662d96afd0666cbd17d86fb35bf9f21fe1d14e04d63c043e7c7c069fd01bb31f47653a2a1d553fc157fbcbf3a145a865d4552afdfae9248ec32539f8cfcd18

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/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/support/from_clause_orderer.rb

@@ -213,8 +213,7 @@ module Bmg
         def _collect_joins(sexpr, joins)
           case sexpr.first
           when :and
-            _collect_joins(sexpr[1], joins)
-            _collect_joins(sexpr[2], joins)
+            sexpr[1..-1].each{ |term| _collect_joins(term, joins) }
           when :eq
             joins << sexpr
           else

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

@@ -2,7 +2,7 @@ module Bmg
   module Version
     MAJOR = 0
     MINOR = 18
-    TINY  = 6
+    TINY  = 10
   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.6
+  version: 0.18.10
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-11 00:00:00.000000000 Z
+date: 2021-11-26 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
@@ -261,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
@@ -272,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
@@ -312,7 +317,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubyforge_project: 
+rubygems_version: 2.6.14.4
 signing_key: 
 specification_version: 4
 summary: Bmg is Alf's successor.