bmg 0.21.4 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59da4b61f1d6c332de148552eab6277032df750c
-  data.tar.gz: b65877260b6a5eca59fb864f52a08dad26f917f4
+  metadata.gz: be420623e04afe03570a1756d1607a202eb96481
+  data.tar.gz: 150b4f3f4daced5825e661765ed4530455263422
 SHA512:
-  metadata.gz: fd85e6e179eb6e1a4d9ffe2f074db3c0d856d239bc65b8d535d6d14cff987a0af1eed75046aed0538726ff87925b9a2a400153a1acec7d7ecc3cc7fdc50d0e87
-  data.tar.gz: 5954aad879e293d34eb175ff54055473e3a983e6a16ec816694eb0b16fd90897cbf9d31bcdf53bfdef664891abb42cb538c7962954d76331c291411e816c956b
+  metadata.gz: 5b2d86803d1bfedfa5605f158a34c744e8b0fa77ed25314e38a28dac6bdef1512bc51a3398cfcd55df42fb60354880b4378b49d339682724cd3da42ef282ef27
+  data.tar.gz: 7321a2b290d2852ff4e2fe52b915e190d3fb13143807e8ac062928c8745a330d70c43fcbbf4abb545507cc8d2b9a05167502c44c7b6d5310c24b2e781920f827

data/README.md

@@ -197,15 +197,17 @@ type = Bmg::Type::ANY.with_keys([[:id]])
 r = Bmg.redis(type, {
   key_prefix: "suppliers",
   redis: Redis.new,
-  serializer: :marshal
+  serializer: :marshal,
+  ttl: 365 * 24 * 60 * 60
 })
 ```
 
-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 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 `ttl` is used to set the validity period of a tuple in redis
+and is optional.
 
 The redis relvars support basic algorithms for insert/update/delete.
 No optimization is currently supported.
@@ -252,12 +254,13 @@ 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
 r.images({:x => r1, :y => r2}, [:a, ...])    # shortcut over image(r1, :x, ...).image(r2, :y, ...)
-r.join(right, [:a, :b, ...])                 # natural join on a join key
-r.join(right, :a => :x, :b => :y, ...)       # natural join after right reversed renaming
+r.join(right, [:a, :b, ...])                 # join on a join key
+r.join(right, :a => :x, :b => :y, ...)       # join after right reversed renaming
 r.left_join(right, [:a, :b, ...], {...})     # left join with optional default right tuple
 r.left_join(right, {:a => :x, ...}, {...})   # left join after right reversed renaming
 r.matching(right, [:a, :b, ...])             # semi join, aka where exists
 r.matching(right, :a => :x, :b => :y, ...)   # semi join, after right reversed renaming
+r.minus(right)                               # set difference
 r.not_matching(right, [:a, :b, ...])         # inverse semi join, aka where not exists
 r.not_matching(right, :a => :x, ...)         # inverse semi join, after right reversed renaming
 r.page([[:a, :asc], ...], 12, page_size: 10) # paging, using an explicit ordering
@@ -268,13 +271,13 @@ r.restrict(a: "foo", b: "bar", ...)          # relational restriction, aka where
 r.rxmatch([:a, :b, ...], /xxx/)              # regex match kind of restriction
 r.summarize([:a, :b, ...], x: :sum)          # relational summarization
 r.suffix(:_foo, but: [:a, ...])              # suffix kind of renaming
-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.transform(:to_s)                           # all-attrs transformation
+r.transform(&:to_s)                          # similar, but Proc-driven
+r.transform(:foo => :upcase, ...)            # specific-attrs tranformation
+r.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.union(right)                               # set 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.rb

@@ -203,6 +203,16 @@ module Bmg
     end
     protected :_union
 
+    def minus(other)
+      return self if other.is_a?(Relation::Empty)
+      _minus self.type.minus(other.type), other
+    end
+
+    def _minus(type, other)
+      Operator::Minus.new(type, [self, other])
+    end
+    protected :_minus
+
     def unwrap(attrs)
       _unwrap self.type.unwrap(attrs), attrs
     end

data/lib/bmg/error.rb

@@ -19,4 +19,8 @@ module Bmg
   # Raised when an operator is badly used
   class MisuseError < Error; end
 
+  # Raised when some compilation is not supported, as an indicator
+  # to backtrack to something more ruby-native.
+  class NotSupportedError < Error; end
+
 end

data/lib/bmg/operator/autowrap.rb

@@ -131,7 +131,7 @@ module Bmg
         else
           super
         end
-      rescue UnknownAttributesError
+      rescue UnsupportedError, UnknownAttributesError
         super
       end
 

data/lib/bmg/operator/constants.rb

@@ -64,7 +64,7 @@ module Bmg
     protected ### optimization
 
       def _page(type, ordering, page_index, options)
-        attrs = ordering.map{|(k,v)| k}
+        attrs = ordering.map{|(k,v)| k }
         cs_attrs = the_constants.keys
         if (attrs & cs_attrs).empty?
           operand
@@ -73,6 +73,8 @@ module Bmg
         else
           super
         end
+      rescue UnsupportedError
+        super
       end
 
       def _restrict(type, predicate)

data/lib/bmg/operator/extend.rb

@@ -133,6 +133,8 @@ module Bmg
         else
           super
         end
+      rescue UnsupportedError
+        super
       end
 
       def _project(type, attrlist)

data/lib/bmg/operator/image.rb

@@ -195,6 +195,8 @@ module Bmg
             .page(ordering, page_index, opts)
             .image(right, as, on, options)
         end
+      rescue UnsupportedError
+        super
       end
 
       def _project(type, attrlist)

data/lib/bmg/operator/minus.rb

@@ -0,0 +1,49 @@
+module Bmg
+  module Operator
+    #
+    # Minus operator.
+    #
+    # Returns all tuples which are in the left operand but not in the right
+    # operand.
+    #
+    # This implementation is actually a NAry-Minus, since it handles
+    # an arbitrary number of operands.
+    #
+    class Minus
+      include Operator::Nary
+
+      def initialize(type, operands)
+        @type = type
+        @operands = operands
+      end
+
+    public
+
+      def each(&bl)
+        return to_enum unless block_given?
+        initial = operands[0].to_set
+        tuples = operands.drop(1).inject(initial) do |agg, op|
+          agg - op.to_set
+        end
+        tuples.each(&bl)
+      end
+
+      def to_ast
+        [ :minus ] + operands.map(&:to_ast)
+      end
+
+    protected ### optimization
+
+      def _minus(type, other)
+        return self if other.is_a?(Relation::Empty)
+        case other
+        when Minus
+          Minus.new(type, operands + other.operands)
+        else
+          Minus.new(type, operands + [other])
+        end
+      end
+
+    end # class Union
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/rename.rb

@@ -76,6 +76,8 @@ module Bmg
           v.nil? ? rr[k] || k : [rr[k] || k, v]
         }
         operand.page(ordering, page_index, options).rename(renaming)
+      rescue UnsupportedError
+        super
       end
 
       def _restrict(type, predicate)

data/lib/bmg/operator.rb

@@ -39,6 +39,7 @@ require_relative 'operator/group'
 require_relative 'operator/image'
 require_relative 'operator/join'
 require_relative 'operator/matching'
+require_relative 'operator/minus'
 require_relative 'operator/not_matching'
 require_relative 'operator/page'
 require_relative 'operator/project'

data/lib/bmg/sql/builder.rb

@@ -157,7 +157,7 @@ module Bmg
       builder :group_by_clause
 
       def order_by_clause(ordering, &desaliaser)
-        ordering.to_a.map{|(name,direction)|
+        ordering.map{|(name,direction)|
           name = name.to_s
           name = (desaliaser && desaliaser[name]) || column_name(name)
           [:order_by_term, name, direction ? direction.to_s : "asc"]

data/lib/bmg/sql/relation.rb

@@ -120,12 +120,15 @@ module Bmg
       end
 
       def _page(type, ordering, page_index, options)
+        pairs = Ordering.new(ordering).to_pairs
         limit  = options[:page_size] || Operator::Page::DEFAULT_OPTIONS[:page_size]
         offset = (page_index - 1) * limit
         expr = before_use(self.expr)
-        expr = Processor::OrderBy.new(ordering, builder).call(expr)
+        expr = Processor::OrderBy.new(pairs, builder).call(expr)
         expr = Processor::LimitOffset.new(limit, offset, builder).call(expr)
         _instance(type, builder, expr)
+      rescue Bmg::NotSupportedError
+        super
       end
 
       def _project(type, attrlist)
@@ -191,6 +194,16 @@ module Bmg
         end
       end
 
+      def _minus(type, right)
+        if right_expr = extract_compatible_sexpr(right)
+          expr = before_use(self.expr)
+          expr = Processor::Merge.new(:except, false, right_expr, builder).call(expr)
+          _instance(type, builder, expr)
+        else
+          super
+        end
+      end
+
       # Build a new relation instance for some new type & expression
       #
       # This method can be overriden by subclasses to provide their

data/lib/bmg/sql.rb

@@ -3,7 +3,7 @@ module Bmg
 
   module Sql
 
-    class NotSupportedError < Bmg::Error; end
+    class NotSupportedError < Bmg::NotSupportedError; end
 
   end # module Sql
 

data/lib/bmg/support/ordering.rb

@@ -1,47 +1,87 @@
 module Bmg
-  class Ordering
+  module Ordering
 
-    def initialize(attrs)
-      @attrs = if attrs.empty?
-        []
-      elsif attrs.first.is_a?(Symbol)
-        attrs.map{|a| [a, :asc] }
+    # Factory over subclasses
+    def self.new(arg)
+      case arg
+      when Ordering
+        arg
+      when Proc
+        Native.new(arg)
       else
-        attrs
+        Attributes.new(arg)
       end
     end
-    attr_reader :attrs
 
     def call(t1, t2)
       comparator.call(t1, t2)
     end
 
-    def comparator
-      @comparator ||= ->(t1, t2) { compare_attrs(t1, t2) }
+    def to_a
+      to_pairs
     end
 
-    def compare_attrs(t1, t2)
-      attrs.each do |(attr,direction)|
-        a1, a2 = t1[attr], t2[attr]
-        if a1.nil? && a2.nil?
-          0
-        elsif a1.nil?
-          return direction == :desc ? -1 : 1
-        elsif a2.nil?
-          return direction == :desc ? 1 : -1
-        elsif a1.respond_to?(:<=>)
-          c = a1 <=> a2
-          unless c.nil? || c==0
-            return direction == :desc ? -c : c
-          end
+    def map(*args, &bl)
+      to_pairs.map(*args, &bl)
+    end
+
+    class Native
+      include Ordering
+
+      def initialize(comparator)
+        @comparator = comparator
+      end
+      attr_reader :comparator
+
+      def to_pairs
+        raise Bmg::NotSupportedError
+      end
+
+    end # class Native
+
+    class Attributes
+      include Ordering
+
+      def initialize(attrs)
+        @attrs = if attrs.empty?
+          []
+        elsif attrs.first.is_a?(Symbol)
+          attrs.map{|a| [a, :asc] }
+        else
+          attrs
         end
       end
-      0
-    end
+      attr_reader :attrs
 
-    def to_a
-      attrs.to_a
-    end
+      def comparator
+        @comparator ||= ->(t1, t2) { compare_attrs(t1, t2) }
+      end
+
+      def to_pairs
+        attrs.to_a
+      end
+
+    private
+
+      def compare_attrs(t1, t2)
+        attrs.each do |(attr,direction)|
+          a1, a2 = t1[attr], t2[attr]
+          if a1.nil? && a2.nil?
+            0
+          elsif a1.nil?
+            return direction == :desc ? -1 : 1
+          elsif a2.nil?
+            return direction == :desc ? 1 : -1
+          elsif a1.respond_to?(:<=>)
+            c = a1 <=> a2
+            unless c.nil? || c==0
+              return direction == :desc ? -c : c
+            end
+          end
+        end
+        0
+      end
 
-  end # class Ordering
+    end # class Attributes
+  end # module Ordering
 end # module Bmg

data/lib/bmg/type.rb

@@ -288,12 +288,7 @@ module Bmg
     end
 
     def union(other)
-      if typechecked? && knows_attrlist? && other.knows_attrlist?
-        missing = self.attrlist - other.attrlist
-        raise TypeError, "Union incompatible: missing right attributes #{missing.join(', ')}" unless missing.empty?
-        extra = other.attrlist - self.attrlist
-        raise TypeError, "Union incompatible: missing left attributes #{extra.join(', ')}" unless extra.empty?
-      end
+      union_compatible!(other, "Union")
       dup.tap{|x|
         ### attrlist stays the same
         x.predicate = self.predicate | predicate
@@ -301,6 +296,17 @@ module Bmg
       }
     end
 
+    def minus(other)
+      union_compatible!(other, "Minus")
+      dup.tap{|x|
+        # 1. attributes do not change
+        # 2. predicate does not change, we can't strengthen it in any way but it
+        #    does not become weaker either
+        # 3. we can safely keep all existing keys, but it's not obvious we can
+        #    gain some new ones
+      }
+    end
+
     def unwrap(attrlist)
       known_attributes!(attrlist) if typechecked? && knows_attrlist?
       dup.tap{|x|
@@ -338,5 +344,14 @@ module Bmg
       end
     end
 
+    def union_compatible!(other, opname)
+      if typechecked? && knows_attrlist? && other.knows_attrlist?
+        missing = self.attrlist - other.attrlist
+        raise TypeError, "#{opname} requires compatible attribute lists, but the right operand is missing the following attributes: #{missing.join(', ')}" unless missing.empty?
+        extra = other.attrlist - self.attrlist
+        raise TypeError, "#{opname} requires compatible attribute lists, but the left operand is missing the following attributes: #{extra.join(', ')}" unless extra.empty?
+      end
+    end
+
   end # class Type
 end # module Bmg

data/lib/bmg/version.rb

@@ -1,8 +1,8 @@
 module Bmg
   module Version
     MAJOR = 0
-    MINOR = 21
-    TINY  = 4
+    MINOR = 22
+    TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/lib/bmg/writer.rb

@@ -16,7 +16,7 @@ module Bmg
       if ordering = output_preferences.tuple_ordering
         relation
           .to_a
-          .sort{|t1,t2| ordering.compare_attrs(t1, t2) }
+          .sort{|t1,t2| ordering.call(t1, t2) }
           .each_with_index(&bl)
       else
         relation.each_with_index(&bl)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.21.4
+  version: 0.22.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-08 00:00:00.000000000 Z
+date: 2024-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -153,6 +153,7 @@ files:
 - lib/bmg/operator/image.rb
 - lib/bmg/operator/join.rb
 - lib/bmg/operator/matching.rb
+- lib/bmg/operator/minus.rb
 - lib/bmg/operator/not_matching.rb
 - lib/bmg/operator/page.rb
 - lib/bmg/operator/project.rb