bmg 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc75e7b5602e1f76e3581009746302b3a546f3f8
-  data.tar.gz: 5dee61974de7699b5ef4957cd2714d5d241df830
+  metadata.gz: e6536b48ec764ca63860c01d8f75b689449c0d29
+  data.tar.gz: 4a5f92f4e5dc65f723e419ccbfe89dd424aa27ef
 SHA512:
-  metadata.gz: cdad32c048da1719f153a16f355a79b13cd68cd18cf017c47041b7d73992f18c19cbdf9c5c32cf366e8801a0ac98a0ef84237120a7f8e59e9d3274feecd8a715
-  data.tar.gz: 28e09b93f01a6aaa0c8e95adba0bf8b417dbf501e9b5b221c8593a5f53f9cdebe04fb636b7fe641ddf41ba3ff6a706de0ab6c9d4c70b70f49f6a9c055e3041cd
+  metadata.gz: 3d9fff6fdabf0f3be88b94cff5a7896d0625d82c47772683c3f40156c7cefa46387c95131c261aeb953978aec013e16acae40d203a9554233a61604fea59e5bb
+  data.tar.gz: 6b8b239b5da4002e2ee96a0946acf7b9636f465f15eeac0f5ee227dc4fcccab68fa00b4b4a32a4827b0e9336e5f46a73036397dabe9855e6ea14351a56279fe8

data/lib/bmg.rb

@@ -1,4 +1,5 @@
 require 'path'
+require 'predicate'
 module Bmg
 
   def csv(path, options = {})
@@ -14,6 +15,9 @@ module Bmg
 end
 require_relative 'bmg/version'
 require_relative 'bmg/error'
-require_relative 'bmg/operator'
+require_relative 'bmg/algebra'
+require_relative 'bmg/type'
 require_relative 'bmg/relation'
+require_relative 'bmg/leaf'
+require_relative 'bmg/operator'
 require_relative 'bmg/reader'

data/lib/bmg/algebra.rb

@@ -0,0 +1,95 @@
+module Bmg
+  module Algebra
+
+    def allbut(butlist = [])
+      _allbut self.type.allbut(butlist), butlist
+    end
+
+    def _allbut(type, butlist)
+      Operator::Allbut.new(type, self, butlist)
+    end
+    protected :_allbut
+
+    def autowrap(options = {})
+      _autowrap self.type.autowrap(options), options
+    end
+
+    def _autowrap(type, options)
+      Operator::Autowrap.new(type, self, options)
+    end
+    protected :_autowrap
+
+    def autosummarize(by = [], summarization = {})
+      _autosummarize type = self.type.autosummarize(by, summarization), by, summarization
+    end
+
+    def _autosummarize(type, by, summarization)
+      Operator::Autosummarize.new(type, self, by, summarization)
+    end
+    protected :_autosummarize
+
+    def constants(cs = {})
+      _constants self.type.constants(cs), cs
+    end
+
+    def _constants(type, cs)
+      Operator::Constants.new(type, self, cs)
+    end
+    protected :_constants
+
+    def extend(extension = {})
+      _extend self.type.extend(extension), extension
+    end
+
+    def _extend(type, extension)
+      Operator::Extend.new(type, self, extension)
+    end
+    protected :_extend
+
+    def image(right, as = :image, on = [], options = {})
+      _image self.type.image(right, as, on, options), right, as, on, options
+    end
+
+    def _image(type, right, as, on, options)
+      Operator::Image.new(type, self, right, as, on, options)
+    end
+    protected :_image
+
+    def project(attrlist = [])
+      _project self.type.project(attrlist), attrlist
+    end
+
+    def _project(type, attrlist)
+      Operator::Project.new(type, self, attrlist)
+    end
+    protected :_project
+
+    def rename(renaming = {})
+      _rename self.type.rename(renaming), renaming
+    end
+
+    def _rename(type, renaming)
+      Operator::Rename.new(type, self, renaming)
+    end
+    protected :_rename
+
+    def restrict(predicate)
+      _restrict self.type.restrict(predicate), Predicate.coerce(predicate)
+    end
+
+    def _restrict(type, predicate)
+      Operator::Restrict.new(type, self, predicate)
+    end
+    protected :_restrict
+
+    def union(other)
+      _union self.type.union(other.type), other
+    end
+
+    def _union(type, other)
+      Operator::Union.new(type, self, other)
+    end
+    protected :_union
+
+  end # module Algebra
+end # module Bmg

data/lib/bmg/leaf.rb

@@ -0,0 +1,18 @@
+module Bmg
+  class Leaf
+    include Relation
+
+    def initialize(type, operand)
+      @operand = operand
+      @type = type
+    end
+    attr_reader :type, :operand
+
+  public
+
+    def each(&bl)
+      @operand.each(&bl)
+    end
+
+  end
+end

data/lib/bmg/operator.rb

@@ -1,15 +1,16 @@
 module Bmg
   module Operator
-
-    def to_a
-      to_enum(:each).to_a
-    end
+    include Relation
 
   end
 end
 require_relative 'operator/allbut'
 require_relative 'operator/autosummarize'
 require_relative 'operator/autowrap'
+require_relative 'operator/constants'
+require_relative 'operator/extend'
+require_relative 'operator/image'
 require_relative 'operator/project'
 require_relative 'operator/rename'
-require_relative 'operator/extend'
+require_relative 'operator/restrict'
+require_relative 'operator/union'

data/lib/bmg/operator/allbut.rb

@@ -17,15 +17,23 @@ module Bmg
     class Allbut
       include Operator
 
-      def initialize(operand, butlist)
+      def initialize(type, operand, butlist)
+        @type = type
         @operand = operand
         @butlist = butlist
       end
+      attr_reader :type
+
+    protected
+
+      attr_reader :operand, :butlist
+
+    public
 
       def each
         seen = {}
         @operand.each do |tuple|
-          allbuted = allbut(tuple)
+          allbuted = tuple_allbut(tuple)
           unless seen.has_key?(allbuted)
             yield(allbuted)
             seen[allbuted] = true
@@ -33,9 +41,15 @@ module Bmg
         end
       end
 
+    protected ### optimization
+
+      def _restrict(type, predicate)
+        operand.restrict(predicate).allbut(butlist)
+      end
+
     private
 
-      def allbut(tuple)
+      def tuple_allbut(tuple)
         tuple.delete_if{|k,_| @butlist.include?(k) }
       end
 

data/lib/bmg/operator/autosummarize.rb

@@ -11,11 +11,19 @@ module Bmg
     class Autosummarize
       include Operator
 
-      def initialize(operand, by, sums)
+      def initialize(type, operand, by, sums)
+        @type = type
         @operand = operand
         @by = by
         @sums = sums.each_with_object({}){|(k,v),h| h[k] = to_summarizer(v) }
       end
+      attr_reader :type
+
+    protected
+
+      attr_reader :operand, :by, :sums
+
+    public
 
       def each(&bl)
         h = {}

data/lib/bmg/operator/autowrap.rb

@@ -25,11 +25,19 @@ module Bmg
         :split => "_"
       }
 
-      def initialize(operand, options = {})
+      def initialize(type, operand, options = {})
+        @type = type
         @operand = operand
         @options = DEFAULT_OPTIONS.merge(options)
         @options[:postprocessor] = NoLeftJoinNoise.new(@options[:postprocessor])
       end
+      attr_reader :type
+
+    private
+
+      attr_reader :operand, :options
+
+    public
 
       def each
         @operand.each do |tuple|

data/lib/bmg/operator/constants.rb

@@ -0,0 +1,57 @@
+module Bmg
+  module Operator
+    #
+    # Constants operator.
+    #
+    # Extends operand's tuples with attributes given at construction.
+    # This is a special case of an extension, where the values are
+    # statically known.
+    #
+    class Constants
+      include Operator
+
+      def initialize(type, operand, constants)
+        @type = type
+        @operand = operand
+        @constants = constants
+      end
+      attr_reader :type
+
+    protected
+
+      attr_reader :operand, :constants
+
+    public
+
+      def each
+        @operand.each do |tuple|
+          yield extend_it(tuple)
+        end
+      end
+
+    protected ### optimization
+
+      def _restrict(type, predicate)
+        top_p, bottom_p = predicate.and_split(constants.keys)
+        if top_p == predicate
+          super
+        else
+          result = operand
+          result = result.restrict(bottom_p) unless bottom_p.tautology?
+          result = result.constants(constants)
+          result = result.restrict(top_p) unless top_p.tautology?
+          result
+        end
+      rescue Predicate::NotSupportedError
+        super
+      end
+
+    private
+
+      def extend_it(tuple)
+        tuple.merge(@constants)
+      end
+
+    end # class Constants
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/extend.rb

@@ -13,10 +13,18 @@ module Bmg
     class Extend
       include Operator
 
-      def initialize(operand, extension)
+      def initialize(type, operand, extension)
+        @type = type
         @operand = operand
         @extension = extension
       end
+      attr_reader :type
+
+    protected
+
+      attr_reader :operand, :extension
+
+    public
 
       def each
         @operand.each do |tuple|

data/lib/bmg/operator/image.rb

@@ -0,0 +1,73 @@
+module Bmg
+  module Operator
+    #
+    # Image operator.
+    #
+    # Extends each tuple with its image in right.
+    #
+    class Image
+      include Operator
+
+      DEFAULT_OPTIONS = {
+
+        # Whether we need to convert each image as an Array,
+        # instead of keeping a Relation instance
+        array: false
+
+      }
+
+      def initialize(type, left, right, as, on, options = {})
+        @type = type
+        @left = left
+        @right = right
+        @as = as
+        @on = on
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+      attr_reader :type
+
+    private
+
+      attr_reader :left, :right, :as, :on, :options
+
+    public
+
+      def each
+        index = Hash.new{|h,k| h[k] = empty_image }
+        right.each_with_object(index) do |t, index|
+          key = tuple_project(t, on)
+          index[key].operand << tuple_image(t, on)
+        end
+        if options[:array]
+          index = index.each_with_object({}) do |(k,v),ix|
+            ix[k] = v.to_a
+          end
+        end
+        left.each do |tuple|
+          key = tuple_project(tuple, on)
+          image = index[key] || (options[:array] ? [] : empty_image)
+          yield tuple.merge(as => image)
+        end
+      end
+
+    private
+
+      def tuple_project(tuple, on)
+        on.each_with_object({}){|k,t| t[k] = tuple[k] }
+      end
+
+      def tuple_image(tuple, on)
+        tuple.dup.delete_if{|k,_| on.include?(k) }
+      end
+
+      def image_type
+        type[as]
+      end
+
+      def empty_image
+        Leaf.new(image_type, Set.new)
+      end
+
+    end # class Project
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/project.rb

@@ -16,10 +16,18 @@ module Bmg
     class Project
       include Operator
 
-      def initialize(operand, attrlist)
+      def initialize(type, operand, attrlist)
+        @type = type
         @operand = operand
         @attrlist = attrlist
       end
+      attr_reader :type
+
+    private
+
+      attr_reader :operand, :attrlist
+
+    public
 
       def each
         seen = {}
@@ -32,6 +40,12 @@ module Bmg
         end
       end
 
+    protected ### optimization
+
+      def _restrict(type, predicate)
+        operand.restrict(predicate).project(attrlist)
+      end
+
     private
 
       def project(tuple)

data/lib/bmg/operator/rename.rb

@@ -16,10 +16,18 @@ module Bmg
     class Rename
       include Operator
 
-      def initialize(operand, renaming)
+      def initialize(type, operand, renaming)
+        @type = type
         @operand = operand
         @renaming = renaming
       end
+      attr_reader :type
+
+    private
+
+      attr_reader :operand, :renaming
+
+    public
 
       def each
         @operand.each do |tuple|

data/lib/bmg/operator/restrict.rb

@@ -0,0 +1,39 @@
+module Bmg
+  module Operator
+    #
+    # Restrict operator.
+    #
+    # Filters operand's tuples to those that meet the predicate received
+    # at construction.
+    #
+    class Restrict
+      include Operator
+
+      def initialize(type, operand, predicate)
+        @type = type
+        @operand = operand
+        @predicate = predicate
+      end
+      attr_reader :type
+
+    protected
+
+      attr_reader :operand, :predicate
+
+    public
+
+      def each
+        @operand.each do |tuple|
+          yield(tuple) if @predicate.evaluate(tuple)
+        end
+      end
+
+    protected
+
+      def _restrict(type, predicate)
+        Restrict.new(type, @operand, @predicate & predicate)
+      end
+
+    end # class Restrict
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/union.rb

@@ -0,0 +1,62 @@
+module Bmg
+  module Operator
+    #
+    # Union operator.
+    #
+    # Returns all tuples of the left operand followed by all
+    # tuples from the right operand.
+    #
+    # By default, this operator strips duplicates, as of relational
+    # theory. Please set the `:all` option to true to avoid this
+    # behavior and save execution time.
+    #
+    class Union
+      include Operator
+
+      DEFAULT_OPTIONS = {
+        all: false
+      }
+
+      def initialize(type, left, right, options = {})
+        @type = type
+        @left = left
+        @right = right
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+      attr_reader :type
+
+    protected
+
+      attr_reader :left, :right, :options
+
+    public
+
+      def all?
+        @options[:all]
+      end
+
+      def each(&bl)
+        if all?
+          @left.each(&bl)
+          @right.each(&bl)
+        else
+          seen = {}
+          @left.each do |tuple|
+            yield(tuple)
+            seen[tuple] = true
+          end
+          @right.each do |tuple|
+            yield(tuple) unless seen.has_key?(tuple)
+          end
+        end
+      end
+
+    protected ### optimization
+
+      def _restrict(type, predicate)
+        left.restrict(predicate).union(right.restrict(predicate))
+      end
+
+    end # class Union
+  end # module Operator
+end # module Bmg

data/lib/bmg/relation.rb

@@ -1,15 +1,10 @@
 module Bmg
-  class Relation
+  module Relation
     include Enumerable
+    include Algebra
 
-    def initialize(operand)
-      @operand = operand
-    end
-
-    ## Consumption methods
-
-    def each(&bl)
-      @operand.each(&bl)
+    def self.new(operand, type = Type::ANY)
+      operand.is_a?(Relation) ? operand : Leaf.new(type, operand)
     end
 
     # Private helper to implement `one` and `one_or_nil`
@@ -36,31 +31,5 @@ module Bmg
       one_or_yield{ nil }
     end
 
-    ## Relational algebra
-
-    def allbut(butlist = [])
-      Relation.new Operator::Allbut.new(@operand, butlist)
-    end
-
-    def autowrap(options = {})
-      Relation.new Operator::Autowrap.new(@operand, options)
-    end
-
-    def autosummarize(by = [], summarization = {})
-      Relation.new Operator::Autosummarize.new(@operand, by, summarization)
-    end
-
-    def extend(extension = {})
-      Relation.new Operator::Extend.new(@operand, extension)
-    end
-
-    def project(attrlist = [])
-      Relation.new Operator::Project.new(@operand, attrlist)
-    end
-
-    def rename(renaming = {})
-      Relation.new Operator::Rename.new(@operand, renaming)
-    end
-
-  end # class Relation
+  end # module Relation
 end # module Bmg

data/lib/bmg/sequel.rb

@@ -0,0 +1,11 @@
+require 'sequel'
+require 'predicate/sequel'
+module Bmg
+
+  def sequel(dataset, type = Type::ANY)
+    Sequel::Relation.new(type, dataset)
+  end
+  module_function :sequel
+
+end
+require_relative 'sequel/relation'

data/lib/bmg/sequel/relation.rb

@@ -0,0 +1,32 @@
+module Bmg
+  module Sequel
+    class Relation
+      include Bmg::Relation
+
+      def initialize(type, dataset)
+        @type = type
+        @dataset = dataset
+      end
+      attr_reader :type
+
+    protected
+
+      attr_reader :dataset
+
+    public
+
+      def each(&bl)
+        @dataset.each(&bl)
+      end
+
+    protected ### optimization
+
+      def _restrict(type, predicate)
+        Relation.new type, dataset.where(predicate.to_sequel)
+      rescue NotImplementedError, Predicate::NotSupportedError
+        super
+      end
+
+    end # class Relation
+  end # module Operator
+end # module Bmg

data/lib/bmg/type.rb

@@ -0,0 +1,51 @@
+module Bmg
+  class Type
+
+    ANY = Type.new
+
+    def [](attribute)
+      ANY
+    end
+
+    def allbut(butlist)
+      ANY
+    end
+
+    def autowrap(options)
+      ANY
+    end
+
+    def autosummarize(by, summarization)
+      ANY
+    end
+
+    def constants(cs)
+      ANY
+    end
+
+    def extend(extension)
+      ANY
+    end
+
+    def image(right, as, on, options)
+      ANY
+    end
+
+    def project(attrlist)
+      ANY
+    end
+
+    def rename(renaming)
+      ANY
+    end
+
+    def restrict(predicate)
+      ANY
+    end
+
+    def union(other)
+      ANY
+    end
+
+  end # class Type
+end # module Bmg

data/lib/bmg/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Bernard Lambeau
@@ -10,6 +10,26 @@ bindir: bin
 cert_chain: []
 date: 2017-11-20 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: predicate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +86,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Bmg is Alf's relational algebra for ruby, but much simpler and lighter
   than Alf itself
 email: blambeau@gmail.com
@@ -78,18 +126,27 @@ files:
 - README.md
 - Rakefile
 - lib/bmg.rb
+- lib/bmg/algebra.rb
 - lib/bmg/error.rb
+- lib/bmg/leaf.rb
 - lib/bmg/operator.rb
 - lib/bmg/operator/allbut.rb
 - lib/bmg/operator/autosummarize.rb
 - lib/bmg/operator/autowrap.rb
+- lib/bmg/operator/constants.rb
 - lib/bmg/operator/extend.rb
+- lib/bmg/operator/image.rb
 - lib/bmg/operator/project.rb
 - lib/bmg/operator/rename.rb
+- lib/bmg/operator/restrict.rb
+- lib/bmg/operator/union.rb
 - lib/bmg/reader.rb
 - lib/bmg/reader/csv.rb
 - lib/bmg/reader/excel.rb
 - lib/bmg/relation.rb
+- lib/bmg/sequel.rb
+- lib/bmg/sequel/relation.rb
+- lib/bmg/type.rb
 - lib/bmg/version.rb
 - tasks/gem.rake
 - tasks/test.rake