bmg 0.19.3 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 773942a08ee8480d73b6d455ef2560c1136002223c86b38ff549beaf280e2760
-  data.tar.gz: 22043853a3d11acde72865db0ad870f2fe033a71e9474ffb1451cc4d69a58d30
+  metadata.gz: 527bf7476d384f3f1be70ff1f77d1886ac75e4c9bbd8fe8e868fefa9971ff34e
+  data.tar.gz: 628ce8e51b75d3244d937f71b1283556ac16a72835aa9cb415f23c8fbb77fc39
 SHA512:
-  metadata.gz: 96dc776f81d2b15093372b843e4bb20c4207e0e59a44842130cb79035fd06ab32fb633f34479c2022b7ad5c958ade798fdc10f07cdcf8db60848d382554067eb
-  data.tar.gz: fa08f7f03dc62e03302e82e68ba0b32505c1fce2f8a78c498c40894de37e1e486e60104e18a7e84761ea56b947bf6c585825ce2462a702b0e85d30601a138ac5
+  metadata.gz: 8948e29965019a1e5fc1204d71a3a423602ea35d4a72ef5e61a7baf12a89f2e653e1428bb4969e731b8ae684e78171c2be0c7c330494c55821d4914b89c46635
+  data.tar.gz: 26e67c96891ed6009c8e8ba1f601053acf71c38951fe0a905c289db83bab40be9809ffabd7c2b5b6287fc9cae1aa6cd1b51dea71cd42f85a9aa77dbfdb70b2bd

data/README.md

@@ -16,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)
@@ -172,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

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

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

@@ -39,9 +39,7 @@ module Bmg
     private
 
       def tuple(row)
-        row.to_hash.each_with_object({}){|(k,v),h|
-          h[k.to_sym] = v
-        }
+        row.to_hash.each_with_object({}){|(k,v),h| h[k.to_sym] = v }
       end
 
       def handle_type(type)

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

@@ -179,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/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
 

data/lib/bmg/support/ordering.rb

@@ -2,13 +2,7 @@ module Bmg
   class Ordering
 
     def initialize(attrs)
-      @attrs = if attrs.empty?
-        []
-      elsif attrs.first.is_a?(Symbol)
-        attrs.map{|a| [a, :asc] }
-      else
-        attrs
-      end
+      @attrs = attrs
     end
     attr_reader :attrs
 
@@ -39,9 +33,5 @@ module Bmg
       0
     end
 
-    def to_a
-      attrs.to_a
-    end
-
   end # class Ordering
 end # module Bmg

data/lib/bmg/support/output_preferences.rb

@@ -3,7 +3,6 @@ module Bmg
 
     DEFAULT_PREFS = {
       attributes_ordering: nil,
-      tuple_ordering: nil,
       extra_attributes: :after
     }
 
@@ -18,12 +17,6 @@ module Bmg
       new(arg)
     end
 
-    def tuple_ordering
-      return nil unless to = options[:tuple_ordering]
-
-      @tuple_ordering = Ordering.new(to)
-    end
-
     def attributes_ordering
       options[:attributes_ordering]
     end
@@ -32,29 +25,10 @@ module Bmg
       options[:extra_attributes]
     end
 
-    def grouping_attributes
-      options[:grouping_attributes]
-    end
-
-    def erase_redundance_in_group(before, current)
-      return [nil, current] unless ga = grouping_attributes
-      return [current, current] unless before
-
-      new_before, new_current = current.dup, current.dup
-      ga.each do |attr|
-        return [new_before, new_current] unless before[attr] == current[attr]
-        new_current[attr] = nil
-      end
-      [new_before, new_current]
-    end
-
     def order_attrlist(attrlist)
       return attrlist if attributes_ordering.nil?
-
       index = Hash[attributes_ordering.each_with_index.to_a]
-      base  = attrlist
-      base  = attrlist & attributes_ordering if extra_attributes == :ignored
-      base.sort{|a,b|
+      attrlist.sort{|a,b|
         ai, bi = index[a], index[b]
         if ai && bi
           ai <=> bi

data/lib/bmg/version.rb

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

data/lib/bmg/writer/csv.rb

@@ -16,14 +16,12 @@ module Bmg
         require 'csv'
         string_or_io, to_s = string_or_io.nil? ? [StringIO.new, true] : [string_or_io, false]
         headers, csv = infer_headers(relation.type), nil
-        previous = nil
-        each_tuple(relation) do |tuple,i|
+        relation.each do |tuple|
           if csv.nil?
             headers = infer_headers(tuple) if headers.nil?
             csv_opts = csv_options.merge(headers: headers)
             csv = CSV.new(string_or_io, **csv_opts)
           end
-          previous, tuple = output_preferences.erase_redundance_in_group(previous, tuple)
           csv << headers.map{|h| tuple[h] }
         end
         to_s ? string_or_io.string : string_or_io

data/lib/bmg/writer/xlsx.rb

@@ -6,11 +6,11 @@ module Bmg
       DEFAULT_OPTIONS = {
       }
 
-      def initialize(xlsx_options, output_preferences = nil)
-        @xlsx_options = DEFAULT_OPTIONS.merge(xlsx_options)
+      def initialize(csv_options, output_preferences = nil)
+        @csv_options = DEFAULT_OPTIONS.merge(csv_options)
         @output_preferences = OutputPreferences.dress(output_preferences)
       end
-      attr_reader :xlsx_options, :output_preferences
+      attr_reader :csv_options, :output_preferences
 
       def call(relation, path)
         require 'write_xlsx'
@@ -21,24 +21,22 @@ module Bmg
       attr_reader :workbook, :worksheet
 
       def _call(relation, path)
-        @workbook = xlsx_options[:workbook] || WriteXLSX.new(path)
-        @worksheet = xlsx_options[:worksheet] || workbook.add_worksheet
+        @workbook = WriteXLSX.new(path)
+        @worksheet = workbook.add_worksheet
 
         headers = infer_headers(relation.type)
-        before = nil
-        each_tuple(relation) do |tuple,i|
+        relation.each_with_index do |tuple,i|
           headers = infer_headers(tuple) if headers.nil?
           headers.each_with_index do |h,i|
             worksheet.write_string(0, i, h)
           end if i == 0
-          before, tuple = output_preferences.erase_redundance_in_group(before, tuple)
           headers.each_with_index do |h,j|
             meth, *args = write_pair(tuple[h])
             worksheet.send(meth, 1+i, j, *args)
           end
         end
 
-        workbook.close unless xlsx_options[:workbook]
+        workbook.close
         path
       end
 

data/lib/bmg/writer.rb

@@ -12,17 +12,6 @@ module Bmg
       attrlist ? output_preferences.order_attrlist(attrlist) : nil
     end
 
-    def each_tuple(relation, &bl)
-      if ordering = output_preferences.tuple_ordering
-        relation
-          .to_a
-          .sort{|t1,t2| ordering.compare_attrs(t1, t2) }
-          .each_with_index(&bl)
-      else
-        relation.each_with_index(&bl)
-      end
-    end
-
   end # module Writer
 end # module Bmg
 require_relative 'writer/csv'

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.3
+  version: 0.20.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-18 00:00:00.000000000 Z
+date: 2022-05-30 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
@@ -318,7 +320,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Bmg is Alf's successor.