bmg 0.19.1 → 0.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52f3bf703312e48ca61bb2dbc88711be1dde8a89
-  data.tar.gz: 4f5029df9dc203d7ec82c0da066771ed61fe6182
+  metadata.gz: 35789fefdd2032b4e807b730fb2fc6f5abe163e1
+  data.tar.gz: 2f20b907d1f66560cbe802c6b3fe3e4064b7bfd0
 SHA512:
-  metadata.gz: e9ac87e62f17250706eefb5ce091e3e77f0b91268910ae0a9fa1446eda6adaeed4ef852d022ecab8c9869b5b5da34db678bf7af811c93de08aad1bec28a39b37
-  data.tar.gz: 7c4117b376c5a406612729c9dfb27b5e22e76ec96e269652bf3a99b53d5c890dfc38c3d269558d08267ca8d4aeaad1c60bad89bc4d24e3b0079a10fc49bff73d
+  metadata.gz: 8c1182190f70a94825505f358701e3ba728eadcfe7026da40f10b7b7dc9b2ff21d8f2f9ec2ccf24baa880b81728e9ef530830e168a33a2742a196c135445d0e5
+  data.tar.gz: b2e7ef1f3bf5983cfd3ff6fbaff820a04f9f118e39df88728ad6c87fec7261269b9fe22f60d44f9d141ce47c78db5e91399345475835f5c88c7b44b16a1c5873

data/README.md

@@ -1,7 +1,5 @@
 # Bmg, a relational algebra (Alf's successor)!
 
-[![Build Status](https://travis-ci.com/enspirit/bmg.svg?branch=master)](https://travis-ci.com/enspirit/bmg)
-
 Bmg is a relational algebra implemented as a ruby library. It implements the
 [Relation as First-Class Citizen](http://www.try-alf.org/blog/2013-10-21-relations-as-first-class-citizen)
 paradigm contributed with [Alf](http://www.try-alf.org/) a few years ago.
@@ -18,6 +16,7 @@ further down this README.
   * [Memory relations](#memory-relations)
   * [Connecting to SQL databases](#connecting-to-sql-databases)
   * [Reading files (csv, excel, text)](#reading-files-csv-excel-text)
+  * [Connecting to Redis databases](#connecting-to-redis-databases)
   * [Your own relations](#your-own-relations)
 * [List of supported operators](#supported-operators)
 * [How is this different?](#how-is-this-different)
@@ -174,6 +173,43 @@ r.type.attrlist
 In this scenario, non matching lines are skipped. The `:line` attribute keeps
 being used to have at least one candidate key (so to speak).
 
+### Connecting to Redis databases
+
+Bmg currently requires `bmg-redis` and `redis >= 4.6` to connect
+to Redis databases. You also need to require `bmg/redis`.
+
+```Gemfile
+gem 'bmg'
+gem 'bmg-redis'
+```
+
+```ruby
+require 'redis'      #  also done by 'bmg/redis' below
+require 'bmg'
+require 'bmg/redis'
+```
+
+Then, you can create Redis relation variables (aka relvars) like
+this:
+
+```ruby
+type = Bmg::Type::ANY.with_keys([[:id]])
+r = Bmg.redis(type, {
+  key_prefix: "suppliers",
+  redis: Redis.new,
+  serializer: :marshal
+})
+```
+
+The key prefix will be used to distinguish the tuples from other
+elements in the same database (e.g. tuples from other relvars).
+The serializer is either `:marshal` or `:json`. Please note that
+types are not preserved when using the second one (all attribute
+values will come back as strings, but keys will be symbolized).
+
+The redis relvars support basic algorithms for insert/update/delete.
+No optimization is currently supported.
+
 ### Your own relations
 
 As noted earlier, Bmg has a simple relation interface where you only have to
@@ -210,6 +246,7 @@ r.autowrap(split: '_')                       # structure a flat relation, split:
 r.autosummarize([:a, :b, ...], x: :sum)      # (experimental) usual summarizers supported
 r.constants(x: 12, ...)                      # add constant attributes (sometimes useful in unions)
 r.extend(x: ->(t){ ... }, ...)               # add computed attributes
+r.extend(x: :y)                              # shortcut for r.extend(x: ->(t){ t[:y] })
 r.exclude(predicate)                         # shortcut for restrict(!predicate)
 r.group([:a, :b, ...], :x)                   # relation-valued attribute from attributes
 r.image(right, :x, [:a, :b, ...])            # relation-valued attribute from another relation

data/lib/bmg/operator/allbut.rb

@@ -50,12 +50,12 @@ module Bmg
         end
       end
 
-      def update(tuple)
-        operand.update(valid_tuple!(tuple))
+      def update(tuple, predicate = Predicate.tautology)
+        operand.update(valid_tuple!(tuple), predicate)
       end
 
-      def delete
-        operand.delete
+      def delete(predicate = Predicate.tautology)
+        operand.delete(predicate)
       end
 
       def to_ast

data/lib/bmg/operator/constants.rb

@@ -10,15 +10,15 @@ module Bmg
     class Constants
       include Operator::Unary
 
-      def initialize(type, operand, constants)
+      def initialize(type, operand, the_constants)
         @type = type
         @operand = operand
-        @constants = constants
+        @the_constants = the_constants
       end
 
     protected
 
-      attr_reader :constants
+      attr_reader :the_constants
 
     public
 
@@ -32,27 +32,27 @@ module Bmg
       def insert(arg)
         case arg
         when Hash       then operand.insert(allbut_constants(arg))
-        when Relation   then operand.insert(arg.allbut(constants.keys))
+        when Relation   then operand.insert(arg.allbut(the_constants.keys))
         when Enumerable then operand.insert(arg.map{|t| allbut_constants(t) })
         else
           super
         end
       end
 
-      def update(tuple)
-        shared = tuple.keys & constants.keys
+      def update(tuple, predicate = Predicate.tautology)
+        shared = tuple.keys & the_constants.keys
         on_tuple = TupleAlgebra.project(tuple, shared)
-        on_const = TupleAlgebra.project(constants, shared)
+        on_const = TupleAlgebra.project(the_constants, shared)
         raise InvalidUpdateError, "Cannot violate relvar predicate" unless on_tuple == on_const
-        operand.update(allbut_constants(tuple))
+        operand.update(allbut_constants(tuple), predicate)
       end
 
-      def delete
-        operand.delete
+      def delete(predicate = Predicate.tautology)
+        operand.delete(predicate)
       end
 
       def to_ast
-        [ :constants, operand.to_ast, constants.dup ]
+        [ :constants, operand.to_ast, the_constants.dup ]
       end
 
     public ### for internal reasons
@@ -65,32 +65,32 @@ module Bmg
 
       def _page(type, ordering, page_index, options)
         attrs = ordering.map{|(k,v)| k}
-        cs_attrs = constants.keys
+        cs_attrs = the_constants.keys
         if (attrs & cs_attrs).empty?
           operand
             .page(ordering, page_index, options)
-            .constants(constants)
+            .constants(the_constants)
         else
           super
         end
       end
 
       def _restrict(type, predicate)
-        # bottom_p makes no reference to constants, top_p possibly
+        # bottom_p makes no reference to the_constants, top_p possibly
         # does...
-        top_p, bottom_p = predicate.and_split(constants.keys)
+        top_p, bottom_p = predicate.and_split(the_constants.keys)
         if top_p.tautology?
-          # push all situation: predicate made no reference to constants
+          # push all situation: predicate made no reference to the_constants
           result = operand
           result = result.restrict(bottom_p)
-          result = result.constants(constants)
+          result = result.constants(the_constants)
           result
-        elsif (top_p.free_variables - constants.keys).empty?
-          # top_p applies to constants only
-          if eval = top_p.evaluate(constants)
+        elsif (top_p.free_variables - the_constants.keys).empty?
+          # top_p applies to the_constants only
+          if eval = top_p.evaluate(the_constants)
             result = operand
             result = result.restrict(bottom_p)
-            result = result.constants(constants)
+            result = result.constants(the_constants)
             result
           else
             Relation.empty(type)
@@ -104,7 +104,7 @@ module Bmg
           # of them
           result = operand
           result = result.restrict(bottom_p)
-          result = result.constants(constants)
+          result = result.constants(the_constants)
           result = result.restrict(top_p)
           result
         end
@@ -115,17 +115,17 @@ module Bmg
     protected ### inspect
 
       def args
-        [ constants ]
+        [ the_constants ]
       end
 
     private
 
       def extend_it(tuple)
-        tuple.merge(@constants)
+        tuple.merge(@the_constants)
       end
 
       def allbut_constants(tuple)
-        TupleAlgebra.allbut(tuple, constants.keys)
+        TupleAlgebra.allbut(tuple, the_constants.keys)
       end
 
     end # class Constants

data/lib/bmg/operator/extend.rb

@@ -42,12 +42,12 @@ module Bmg
         end
       end
 
-      def update(tuple)
-        operand.update(allbut_extkeys(tuple))
+      def update(tuple, predicate = Predicate.tautology)
+        operand.update(allbut_extkeys(tuple), predicate)
       end
 
-      def delete
-        operand.delete
+      def delete(predicate = Predicate.tautology)
+        operand.delete(predicate)
       end
 
       def to_ast
@@ -160,7 +160,12 @@ module Bmg
 
       def extend_it(tuple)
         @extension.each_with_object(tuple.dup) { |(k,v), memo|
-          memo[k] = v.call(tuple)
+          memo[k] = case v
+          when Symbol
+            tuple[v]
+          else
+            v.call(tuple)
+          end
           memo
         }
       end

data/lib/bmg/operator/project.rb

@@ -49,12 +49,12 @@ module Bmg
         end
       end
 
-      def update(tuple)
-        operand.update(valid_tuple!(tuple))
+      def update(tuple, predicate = Predicate.tautology)
+        operand.update(valid_tuple!(tuple), predicate)
       end
 
-      def delete
-        operand.delete
+      def delete(predicate = Predicate.tautology)
+        operand.delete(predicate)
       end
 
       def to_ast

data/lib/bmg/operator/rename.rb

@@ -45,16 +45,17 @@ module Bmg
         end
       end
 
-      def update(arg)
+      def update(arg, predicate = Predicate.tautology)
         case arg
-        when Hash then operand.update(rename_tuple(arg, reverse_renaming))
+        when Hash
+          operand.update(rename_tuple(arg, reverse_renaming), predicate)
         else
           super
         end
       end
 
-      def delete
-        operand.delete
+      def delete(predicate = Predicate.tautology)
+        operand.delete(predicate)
       end
 
       def to_ast

data/lib/bmg/operator/restrict.rb

@@ -32,6 +32,18 @@ module Bmg
         end
       end
 
+      def insert(tuple)
+        operand.insert(tuple)
+      end
+
+      def update(updating, predicate = Predicate.tautology)
+        operand.update(updating, predicate & self.predicate)
+      end
+
+      def delete(predicate = Predicate.tautology)
+        operand.delete(predicate & self.predicate)
+      end
+
       def to_ast
         [ :restrict, operand.to_ast, predicate.sexpr ]
       end

data/lib/bmg/relation/in_memory/mutable.rb

@@ -0,0 +1,23 @@
+module Bmg
+  module Relation
+    class InMemory
+      class Mutable < InMemory
+        def insert(arg)
+          raise ArgumentError unless arg.is_a?(Hash)
+
+          @operand << arg.dup
+        end
+
+        def update(updating, predicate = Predicate.tautology)
+          @operand = @operand.map{|t|
+            predicate.call(t) ? t.merge(updating) : t
+          }
+        end
+
+        def delete(predicate = Predicate.tautology)
+          @operand = @operand.select{|t| predicate.call(t) }
+        end
+      end # class Mutable
+    end # class InMemory
+  end # module Relation
+end # module Bmg

data/lib/bmg/relation/in_memory.rb

@@ -41,3 +41,4 @@ module Bmg
     end # class InMemory
   end # module Relation
 end # module Bmg
+require_relative 'in_memory/mutable'

data/lib/bmg/relation.rb

@@ -74,16 +74,16 @@ module Bmg
       one_or_yield{ nil }
     end
 
-    def insert(arg)
-      raise InvalidUpdateError, "Cannot insert into this Relvar"
+    def insert(*args, &bl)
+      raise InvalidUpdateError, "Cannot insert into #{self.class.name}"
     end
 
-    def update(arg)
-      raise InvalidUpdateError, "Cannot update this Relvar"
+    def update(*args, &bl)
+      raise InvalidUpdateError, "Cannot update #{self.class.name}"
     end
 
-    def delete
-      raise InvalidUpdateError, "Cannot delete from this Relvar"
+    def delete(*args, &bl)
+      raise InvalidUpdateError, "Cannot delete from #{self.class.name}"
     end
 
     def visit(&visitor)

data/lib/bmg/sequel/predicate_translator.rb

@@ -0,0 +1,22 @@
+module Bmg
+  module Sequel
+    class PredicateTranslator < Sexpr::Processor
+      include ::Predicate::ToSequel::Methods
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+    public ### Predicate hack
+
+      def on_opaque(sexpr)
+        @parent.apply(sexpr.last)
+      end
+
+      def on_exists(sexpr)
+        @parent.apply(sexpr.last).exists
+      end
+
+    end # class PredicateTranslator
+  end # module Sequel
+end # module Bmg

data/lib/bmg/sequel/relation.rb

@@ -13,8 +13,13 @@ module Bmg
         dataset.each(&bl)
       end
 
-      def delete
-        base_table.delete
+      def delete(predicate = Predicate.tautology)
+        target = base_table
+        unless predicate.tautology?
+          compiled = compile_predicate(predicate)
+          target = base_table.where(compiled)
+        end
+        target.delete
       end
 
       def insert(arg)
@@ -30,8 +35,13 @@ module Bmg
         end
       end
 
-      def update(arg)
-        base_table.update(arg)
+      def update(arg, predicate = Predicate.tautology)
+        target = base_table
+        unless predicate.tautology?
+          compiled = compile_predicate(predicate)
+          target = base_table.where(compiled)
+        end
+        target.update(arg)
       end
 
       def _count
@@ -73,6 +83,10 @@ module Bmg
         operand.expr
       end
 
+      def compile_predicate(predicate)
+        Translator.new(sequel_db).compile_predicate(predicate)
+      end
+
     end # class Relation
   end # module Sequel
 end # module Bmg

data/lib/bmg/sequel/translator.rb

@@ -81,6 +81,7 @@ module Bmg
         case sexpr.func_name
         when :cast
           to_cast = apply(sexpr.func_args.first)
+          to_cast = ::Sequel.expr(nil) if to_cast.nil?
           type = sexpr.func_args.last.last
           to_cast.cast(type)
         else
@@ -178,36 +179,19 @@ module Bmg
         sexpr.last
       end
 
-    private
-
-      def dataset(expr)
-        return expr if ::Sequel::Dataset===expr
-        sequel_db[expr]
-      end
+    public
 
       def compile_predicate(predicate)
         PredicateTranslator.new(self).call(predicate)
       end
 
-    class PredicateTranslator < Sexpr::Processor
-      include ::Predicate::ToSequel::Methods
-
-      def initialize(parent)
-        @parent = parent
-      end
-
-    public ### Predicate hack
-
-      def on_opaque(sexpr)
-        @parent.apply(sexpr.last)
-      end
+    private
 
-      def on_exists(sexpr)
-        @parent.apply(sexpr.last).exists
+      def dataset(expr)
+        return expr if ::Sequel::Dataset===expr
+        sequel_db[expr]
       end
 
-    end
-
     end # class Translator
   end # module Sequel
 end # module Bmg

data/lib/bmg/sequel.rb

@@ -62,5 +62,6 @@ module Bmg
 end
 require_relative 'sequel/ext'
 require_relative 'sequel/translator'
+require_relative 'sequel/predicate_translator'
 require_relative 'sequel/type_inference'
 require_relative 'sequel/relation'

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

@@ -0,0 +1,33 @@
+module Bmg
+  module Sql
+    class Processor
+      class Extend < Processor
+
+        def initialize(extension, builder)
+          super(builder)
+          @extension = extension
+        end
+        attr_reader :extension
+
+        def on_set_operator(sexpr)
+          apply(builder.from_self(sexpr))
+        end
+        alias :on_union     :on_set_operator
+        alias :on_except    :on_set_operator
+        alias :on_intersect :on_set_operator
+
+        def on_select_star(sexpr)
+          raise NotImplementedError, "Extend on * is not supported"
+        end
+
+        def on_select_list(sexpr)
+          sexpr + extension.each_pair.map{|(k,v)|
+            desaliased = sexpr.desaliaser[v]
+            [:select_item, desaliased, [:column_name, k] ]
+          }
+        end
+
+      end # class Extend
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -10,7 +10,7 @@ module Bmg
 
         def on_select_list(sexpr)
           reordered = sexpr.sexpr_body.sort{|i1,i2|
-            @indexes[i1.as_name] <=> @indexes[i2.as_name]
+            @indexes[i1.as_name.to_s] <=> @indexes[i2.as_name.to_s]
           }
           reordered.unshift(:select_list)
         end

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

@@ -39,9 +39,10 @@ module Bmg
         def falsy?(sexpr)
           return false unless sexpr.respond_to?(:predicate)
           return false if sexpr.predicate.nil?
+
           left  = Predicate.new(Predicate::Grammar.sexpr(sexpr.predicate)).unqualify
           right = Predicate.new(Predicate::Grammar.sexpr(@predicate.sexpr)).unqualify
-          return (left & right).contradiction?
+          (left & right).contradiction?
         end
 
       end # class Where

data/lib/bmg/sql/processor.rb

@@ -71,6 +71,7 @@ require_relative 'processor/distinct'
 require_relative 'processor/all'
 require_relative 'processor/clip'
 require_relative 'processor/constants'
+require_relative 'processor/extend'
 require_relative 'processor/star'
 require_relative 'processor/rename'
 require_relative 'processor/order_by'

data/lib/bmg/sql/relation.rb

@@ -27,15 +27,15 @@ module Bmg
         raise NotImplementedError
       end
 
-      def delete
+      def delete(*args, &bl)
         raise NotImplementedError
       end
 
-      def insert(arg)
+      def insert(*args, &bl)
         raise NotImplementedError
       end
 
-      def update(arg)
+      def update(*args, &bl)
         raise NotImplementedError
       end
 
@@ -57,6 +57,23 @@ module Bmg
         _instance(type, builder, expr)
       end
 
+      def _extend(type, extension)
+        supported, unsupported = {}, {}
+        extension.each_pair do |k,v|
+          (v.is_a?(Symbol) ? supported : unsupported)[k] = v
+        end
+        if supported.empty?
+          Operator::Extend.new(type, self, extension)
+        elsif unsupported.empty?
+          expr = Processor::Extend.new(supported, builder).call(self.expr)
+          _instance(type, builder, expr)
+        else
+          expr = Processor::Extend.new(supported, builder).call(self.expr)
+          operand = _instance(type.allbut(unsupported.keys), builder, expr)
+          Operator::Extend.new(type, operand, unsupported)
+        end
+      end
+
       def _join(type, right, on)
         if right_expr = extract_compatible_sexpr(right)
           right_expr = Processor::Requalify.new(builder).call(right_expr)

data/lib/bmg/version.rb

@@ -1,7 +1,7 @@
 module Bmg
   module Version
     MAJOR = 0
-    MINOR = 19
+    MINOR = 20
     TINY  = 1
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

data/lib/bmg.rb

@@ -4,6 +4,11 @@ require 'forwardable'
 require 'set'
 module Bmg
 
+  def mutable(enumerable, type = Type::ANY)
+    Relation::InMemory::Mutable.new(type, enumerable).spied(main_spy)
+  end
+  module_function :mutable
+
   def in_memory(enumerable, type = Type::ANY)
     Relation::InMemory.new(type, enumerable).spied(main_spy)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.20.1
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-21 00:00:00.000000000 Z
+date: 2022-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -174,11 +174,13 @@ files:
 - lib/bmg/relation.rb
 - lib/bmg/relation/empty.rb
 - lib/bmg/relation/in_memory.rb
+- lib/bmg/relation/in_memory/mutable.rb
 - lib/bmg/relation/materialized.rb
 - lib/bmg/relation/proxy.rb
 - lib/bmg/relation/spied.rb
 - lib/bmg/sequel.rb
 - lib/bmg/sequel/ext.rb
+- lib/bmg/sequel/predicate_translator.rb
 - lib/bmg/sequel/relation.rb
 - lib/bmg/sequel/translator.rb
 - lib/bmg/sequel/type_inference.rb
@@ -248,6 +250,7 @@ files:
 - lib/bmg/sql/processor/clip.rb
 - lib/bmg/sql/processor/constants.rb
 - lib/bmg/sql/processor/distinct.rb
+- lib/bmg/sql/processor/extend.rb
 - lib/bmg/sql/processor/flatten.rb
 - lib/bmg/sql/processor/from_self.rb
 - lib/bmg/sql/processor/join.rb