bmg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9e90b71aeb478997a7f9efcea3a18cec7ad3fac3
+  data.tar.gz: 9ebdd9b06a635ef12cef5d7c35d4746a56932bba
+SHA512:
+  metadata.gz: a662b415f76df21dfad0d4e4b6f7c9dece45c994a7200c4d547f21007fd8158812a0e8c0fb263f0e4d3da597d334e03ed8394a28b052927f7f58081bf65ee392
+  data.tar.gz: 520d850977384a3cff1aa7e8fe58f52ea34e9f7f8caa0d9ec1f4849a92bab50814bbdaeb4ad8b0cd551ab8b3424d1d57f42fbab51bbe22fa7f6824e5aa610159

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE.md

@@ -0,0 +1,22 @@
+# The MIT Licence
+
+    Copyright (c) 2017 - Enspirit SPRL (Bernard Lambeau)
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+## Bmg, Alf's successor, the relational algebra!
+
+Coming soon.

data/Rakefile

@@ -0,0 +1,11 @@
+#
+# Install all tasks found in tasks folder
+#
+# See .rake files there for complete documentation.
+#
+Dir["tasks/*.rake"].each do |taskfile|
+  load taskfile
+end
+
+# We run tests by default
+task :default => :test

data/lib/bmg.rb

@@ -0,0 +1,18 @@
+require 'path'
+module Bmg
+
+  def csv(path, options = {})
+    Relation.new Reader::Csv.new path, options
+  end
+  module_function :csv
+
+  def excel(path, options = {})
+    Relation.new Reader::Excel.new path, options
+  end
+  module_function :excel
+
+end
+require_relative 'bmg/version'
+require_relative 'bmg/operator'
+require_relative 'bmg/relation'
+require_relative 'bmg/reader'

data/lib/bmg/operator.rb

@@ -0,0 +1,14 @@
+module Bmg
+  module Operator
+
+    def to_a
+      to_enum(:each).to_a
+    end
+
+  end
+end
+require_relative 'operator/allbut'
+require_relative 'operator/autosummarize'
+require_relative 'operator/autowrap'
+require_relative 'operator/project'
+require_relative 'operator/rename'

data/lib/bmg/operator/allbut.rb

@@ -0,0 +1,44 @@
+module Bmg
+  module Operator
+    #
+    # Allbut operator.
+    #
+    # Projects operand's tuples on all but given attributes, that is,
+    # removes attributes in the list. The operator takes care of removing
+    # duplicates.
+    #
+    # Example:
+    #
+    #   [{ a: 1, b: 2 }] allbut [:b] => [{ a: 1 }]
+    #
+    # All attributes in the butlist SHOULD be existing attributes of the
+    # input tuples.
+    #
+    class Allbut
+      include Operator
+
+      def initialize(operand, butlist)
+        @operand = operand
+        @butlist = butlist
+      end
+
+      def each
+        seen = {}
+        @operand.each do |tuple|
+          allbuted = allbut(tuple)
+          unless seen.has_key?(allbuted)
+            yield(allbuted)
+            seen[allbuted] = true
+          end
+        end
+      end
+
+    private
+
+      def allbut(tuple)
+        tuple.delete_if{|k,_| @butlist.include?(k) }
+      end
+
+    end # class Allbut
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/autosummarize.rb

@@ -0,0 +1,190 @@
+module Bmg
+  module Operator
+    #
+    # Autosummarize operator.
+    #
+    # Autosummarize helps structuring the results of a big flat join.
+    #
+    # This operator is still largely experimental and should be used with
+    # care...
+    #
+    class Autosummarize
+      include Operator
+
+      def initialize(operand, by, sums)
+        @operand = operand
+        @by = by
+        @sums = sums.each_with_object({}){|(k,v),h| h[k] = to_summarizer(v) }
+      end
+
+      def each(&bl)
+        h = {}
+        @operand.each do |tuple|
+          key = key(tuple)
+          h[key] ||= init(key, tuple)
+          h[key] = sum(h[key], tuple)
+        end
+        h.each_pair do |k,v|
+          h[k] = term(v)
+        end
+        h.values.each(&bl)
+      end
+
+    private
+
+      # Returns the tuple determinant.
+      def key(tuple)
+        @by.map{|by| tuple[by] }
+      end
+
+      # Returns the initial tuple to use for a given determinant.
+      def init(key, tuple)
+        tuple.each_with_object({}){|(k,v),h|
+          h.merge!(k => summarizer(k).init(v))
+        }
+      end
+
+      # Returns the summarizer to use for a given key.
+      def summarizer(k)
+        @sums[k] || Same.new
+      end
+
+      # Sums `tuple` on `memo`, returning the new tuple to use as memo.
+      def sum(memo, tuple)
+        tuple.each_with_object(memo.dup){|(k,v),h|
+          h.merge!(k => summarizer(k).sum(h[k], v))
+        }
+      end
+
+      # Terminates the summarization of a given tuple.
+      def term(tuple)
+        tuple.each_with_object({}){|(k,v),h|
+          h.merge!(k => summarizer(k).term(v))
+        }
+      end
+
+      def to_summarizer(x)
+        case x
+        when :same  then Same.new
+        when :group then DistinctList.new
+        else
+          x
+        end
+      end
+
+      #
+      # Summarizes by enforcing that the same dependent is observed for a given
+      # determinant, returning the dependent as summarization.
+      #
+      class Same
+
+        def init(v)
+          v
+        end
+
+        def sum(v1, v2)
+          raise "Same values expected, got `#{v1}` vs. `#{v2}`" unless v1 == v2
+          v1
+        end
+
+        def term(v)
+          v
+        end
+
+      end # class Same
+
+      #
+      # Summarizes by putting distinct dependents inside an Array, ignoring nils,
+      # and optionally sorting the array.
+      #
+      class DistinctList
+
+        def initialize(&sorter)
+          @sorter = sorter
+        end
+
+        def init(v)
+          Set.new v.nil? ? [] : [v]
+        end
+
+        def sum(v1, v2)
+          v1 << v2 unless v2.nil?
+          v1
+        end
+
+        def term(v)
+          v = v.to_a
+          v = v.sort(&@sorter) if @sorter
+          v
+        end
+
+      end # class DistinctList
+
+      #
+      # Summarizes by converting dependents to { x => y, ... } such that `x` is not
+      # null and `y` is the value observed for `x`.
+      #
+      class YByX
+
+        def initialize(y, x, preserve_nulls = false)
+          @y = y
+          @x = x
+          @preserve_nulls = preserve_nulls
+        end
+
+        def init(v)
+          [v]
+        end
+
+        def sum(v1, v2)
+          v1 << v2
+        end
+
+        def term(v)
+          h = {}
+          v.each do |tuple|
+            next if tuple[@x].nil?
+            h[tuple[@x]] = tuple[@y] if not tuple[@y].nil? or @preserve_nulls
+          end
+          h
+        end
+
+      end # class YByX
+
+      #
+      # Summarizes by converting dependents to { x => [ys], ... } such that `x` is not
+      # null and `[ys]` is a distinct list of observed non-null `y`.
+      #
+      class YsByX
+
+        def initialize(y, x, &sorter)
+          @y = y
+          @x = x
+          @sorter = sorter
+        end
+
+        def init(v)
+          [v]
+        end
+
+        def sum(v1, v2)
+          v1 << v2
+        end
+
+        def term(v)
+          h = {}
+          v = v.reject{|tuple| tuple[@x].nil? }
+          v = v.sort(&@sorter) if @sorter
+          v.each do |tuple|
+            h[tuple[@x]] ||= []
+            h[tuple[@x]] << tuple[@y]
+            h[tuple[@x]].uniq!
+          end
+          h
+        end
+
+      end # class YsByX
+
+    end # class Autosummarize
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/autowrap.rb

@@ -0,0 +1,109 @@
+module Bmg
+  module Operator
+    #
+    # Autowrap operator.
+    #
+    # Autowrap can be used to structure tuples ala Tutorial D' wrap, but it works
+    # with conventions instead of explicit wrapping, and supports multiple levels
+    # or wrapping.
+    #
+    # Examples:
+    #
+    #   [{ a: 1, b_x: 2, b_y: 3 }]     => [{ a: 1, b: { x: 2, y: 3 } }]
+    #   [{ a: 1, b_x_y: 2, b_x_z: 3 }] => [{ a: 1, b: { x: { y: 2, z: 3 } } }]
+    #
+    # Autowrap supports the following options:
+    #
+    # - `postprocessor: :nil|:none|:delete|Hash|Proc` see NoLeftJoinNoise
+    # - `split: String` the seperator to use to split keys, defaults to `_`
+    #
+    class Autowrap
+      include Operator
+
+      DEFAULT_OPTIONS = {
+        :postprocessor => :none,
+        :split => "_"
+      }
+
+      def initialize(operand, options = {})
+        @operand = operand
+        @options = DEFAULT_OPTIONS.merge(options)
+        @options[:postprocessor] = NoLeftJoinNoise.new(@options[:postprocessor])
+      end
+
+      def each
+        @operand.each do |tuple|
+          yield autowrap(tuple)
+        end
+      end
+
+    private
+
+      def autowrap(tuple)
+        separator = @options[:split]
+        autowrapped = tuple.each_with_object({}){|(k,v),h|
+          parts = k.to_s.split(separator).map(&:to_sym)
+          sub = h
+          parts[0...-1].each do |part|
+            sub = (sub[part] ||= {})
+          end
+          sub[parts[-1]] = v
+          h
+        }
+        autowrapped = postprocessor.call(autowrapped)
+        autowrapped
+      end
+
+      def postprocessor
+        @options[:postprocessor]
+      end
+
+      #
+      # Removes the noise generated by left joins that were not join.
+      #
+      # i.e. x is removed in { x: { id: nil, name: nil, ... } }
+      #
+      # Supported heuristics are:
+      #
+      # - nil:    { x: { id: nil, name: nil, ... } } => { x: nil }
+      # - delete: { x: { id: nil, name: nil, ... } } => { }
+      # - none:   { x: { id: nil, name: nil, ... } } => { x: { id: nil, name: nil, ... } }
+      # - a Hash, specifying a specific heuristic by tuple attribute
+      # - a Proc, `->(tuple,key){ ... }` that affects the tuple manually
+      #
+      class NoLeftJoinNoise
+
+        REMOVERS = {
+          nil:    ->(t,k){ t[k] = nil  },
+          delete: ->(t,k){ t.delete(k) },
+          none:   ->(t,k){ t           }
+        }
+
+        def initialize(remover)
+          @remover = case remover
+          when NilClass then REMOVERS[:none]
+          when Proc     then remover
+          when Symbol   then REMOVERS[remover]
+          when Hash     then ->(t,k){ REMOVERS[remover[k] || :none].call(t,k) }
+          else
+            raise "Invalid remover `#{remover}`"
+          end
+        end
+
+        def call(tuple)
+          tuple.each_key do |k|
+            @remover.call(tuple, k) if tuple[k].is_a?(Hash) && all_nil?(tuple[k])
+          end
+          tuple
+        end
+
+        def all_nil?(tuple)
+          return false unless tuple.is_a?(Hash)
+          tuple.all?{|(k,v)| v.nil? || all_nil?(tuple[k]) }
+        end
+
+      end # NoLeftJoinNoise
+
+    end # class Autowrap
+  end # module Operator
+end # module Bmg

data/lib/bmg/operator/project.rb

@@ -0,0 +1,43 @@
+module Bmg
+  module Operator
+    #
+    # Project operator.
+    #
+    # Projects operand's tuples on given attributes, that is, keep those attributes
+    # only. The operator takes care of removing duplicates.
+    #
+    # Example:
+    #
+    #   [{ a: 1, b: 2 }] project [:b] => [{ b: 2 }]
+    #
+    # All attributes in the attrlist SHOULD be existing attributes of the
+    # input tuples.
+    #
+    class Project
+      include Operator
+
+      def initialize(operand, attrlist)
+        @operand = operand
+        @attrlist = attrlist
+      end
+
+      def each
+        seen = {}
+        @operand.each do |tuple|
+          projected = project(tuple)
+          unless seen.has_key?(projected)
+            yield(projected)
+            seen[projected] = true
+          end
+        end
+      end
+
+    private
+
+      def project(tuple)
+        tuple.delete_if{|k,_| !@attrlist.include?(k) }
+      end
+
+    end # class Project
+  end # module Operator
+end # module Bmg