bmg 0.18.6 → 0.18.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 482e0bb06c06e4afc620696491cf75f788902240c75f9c82d71ce9b0db4deee1
-  data.tar.gz: f49609c7cf929149d91bb1c29703fd4e5fb7d861073b38ad916a851214ec20b9
+  metadata.gz: b7b4d39e83f04ee58369bef32ce396893d5ac98d357fd8c497d309fa17cc93b2
+  data.tar.gz: b36344887bb1142c4ddd3de0eb4419c0ba1821490a9c8c336668c37008e59156
 SHA512:
-  metadata.gz: a4068309c373faa50bfc4549648ee26e3220187192a529ee8c6c890424c52b4d05103c2ebf7b137354c1c8a82a756eafbdb5c6b266f489c3c6e0a0b9923a4d15
-  data.tar.gz: ba7a0046919e2d796c58cae326f3d4cf7b86f6d577e34f79395c04286c4bf463cb4c349cb2a5ce4611fbd6e310ebf521736fb190bcc1d1c2c42c51ccc175fb2e
+  metadata.gz: c21cc2eb5c0e0e93cb8c4afc823855140051112f6ac5bd896181634edb67f87fca9b88f4a16c0ec70da36c8ce937e3265ade2506e7077f103e4fb46409b8dded
+  data.tar.gz: b40c206ad43a6ec36e4951c8ff8d531872154e0e855f055f62059ff3af9f0d35e7d96f2443e8046bd107741c4df481aa4ebc2b680ccf1fc88181b988add1d2d6

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/sequel/translator.rb

@@ -78,8 +78,15 @@ 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)

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/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,13 +137,27 @@ 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)
@@ -153,7 +167,7 @@ module Bmg
       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/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  = 7
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.18.6
+  version: 0.18.7
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-11 00:00:00.000000000 Z
+date: 2021-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -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