bmg 0.17.3 → 0.17.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90ed0f35cc6ced83ada1d6aeb3162b7fb8c1bb3f6f20f870f030c589e991e97e
-  data.tar.gz: 959415999253759d072fae5e5280417cdbd5fd8774bbf90e541b74f2324d197c
+  metadata.gz: 600739b827185e0d02252824b7b5616662a378b1c907a632ba695536e76d631e
+  data.tar.gz: f327e31860ef19e0ab8177ebd0e3d0c927c003cb25b8e48af202145cdf1ceece
 SHA512:
-  metadata.gz: fbb3cb7ea042873933e6c15f5ee73084980066cc3ee8c8c58c5169b3221a1aa4c2d97a1521618c456da0d34097df456ef34081a8a418429d1627ed2ada36c1ec
-  data.tar.gz: 687eed5fc05caa9c7dba8258aeb70b929877d6c56c45212ac04358df562acf4ffdc57f199c8d774d43631f82088fa70cac78b1754ae2bfbdd8eaa4d61b156014
+  metadata.gz: 2cd09c0006211c6db5d220ee2371669bd3e29bf32c71eae9fb9ba2c4698392ed172412bbd71c9eded5df34172ab469aa6d20a4117ef263955ed73e8a128cf856
+  data.tar.gz: 8777307569c78001741a597b3ecd9974aa1ee94780495d86f97af38313dcd185c9516d43b9c1635cae5e57606c7422d3e6b3f4889be0b2adcdfeb9f2c30dee24

data/README.md

@@ -14,7 +14,7 @@ also much simpler, and make its easier to implement user-defined relations.
 
 ## Example
 
-```
+```ruby
 require 'bmg'
 require 'json'
 
@@ -32,13 +32,14 @@ by_city = suppliers
   .group([:sid, :name, :status], :suppliers_in)
 
 puts JSON.pretty_generate(by_city)
+# [{...},...]
 ```
 
 ## Connecting to a SQL database
 
 Bmg requires `sequel >= 3.0` to connect to SQL databases.
 
-```
+```ruby
 require 'sqlite3'
 require 'bmg'
 require 'bmg/sequel'
@@ -47,16 +48,67 @@ DB = Sequel.connect("sqlite://suppliers-and-parts.db")
 
 suppliers = Bmg.sequel(:suppliers, DB)
 
-puts suppliers
+big_suppliers = suppliers
   .restrict(Predicate.neq(status: 30))
-  .to_sql
 
+puts big_suppliers.to_sql
 # SELECT `t1`.`sid`, `t1`.`name`, `t1`.`status`, `t1`.`city` FROM `suppliers` AS 't1' WHERE (`t1`.`status` != 30)
+
+puts JSON.pretty_generate(big_suppliers)
+# [{...},...]
 ```
 
+## How is this different from similar libraries?
+
+1. The libraries you probably know (Sequel, Arel, SQLAlchemy, Korma, jOOQ,
+   etc.) do not implement a genuine relational algebra: their support for
+   chaining relational operators is limited (yielding errors or wrong SQL
+   queries). Bmg **always** allows chaining operators. If it does not, it's
+   a bug. In other words, the following query is 100% valid:
+
+       relation
+         .restrict(...)    # aka where
+         .union(...)
+         .summarize(...)   # aka group by
+         .restrict(...)
+
+2. Bmg supports in memory relations, json relations, csv relations, SQL
+   relations and so on. It's not tight to SQL generation, and supports
+   queries accross multiple data sources.
+
+3. Bmg makes a best effort to optimize queries, simplifying both generated
+   SQL code (low-level accesses to datasources) and in-memory operations.
+
+4. Bmg supports various *structuring* operators (group, image, autowrap,
+   autosummarize, etc.) and allows building 'non flat' relations.
+
+## How is this different from Alf?
+
+1. Bmg's implementation is much simpler than Alf, and uses no ruby core
+   extention.
+
+2. We are confident using Bmg in production. Systematic inspection of query
+   plans is suggested though. Alf was a bit too experimental to be used on
+   (critical) production systems.
+
+2. Alf exposes a functional syntax, command line tool, restful tools and
+   many more. Bmg is limited to the core algebra, main Relation abstraction
+   and SQL generation.
+
+3. Bmg is less strict regarding conformance to relational theory, and
+   may actually expose non relational features (such as support for null,
+   left_join operator, etc.). Sharp tools hurt, use them with great care.
+
+4. Bmg does not yet implement all operators documented on try-alf.org, even
+   if we plan to eventually support them all.
+
+5. Bmg has a few additional operators that prove very useful on real
+   production use cases: prefix, suffix, autowrap, autosummarize, left_join,
+   rxmatch, etc.
+
 ## Supported operators
 
-```
+```ruby
 r.allbut([:a, :b, ...])                      # remove specified attributes
 r.autowrap(split: '_')                       # structure a flat relation, split: '_' is the default
 r.autosummarize([:a, :b, ...], x: :sum)      # (experimental) usual summarizers supported
@@ -66,6 +118,8 @@ r.group([:a, :b, ...], :x)                   # relation-valued attribute from at
 r.image(right, :x, [:a, :b, ...])            # relation-valued attribute from another relation
 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.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.not_matching(right, [:a, :b, ...])         # inverse semi join, aka where not exists
@@ -78,5 +132,19 @@ 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.union(right)                               # relational union
 ```
+
+## Who is behind Bmg?
+
+Bernard Lambeau (bernard@klaro.cards) is Alf & Bmg main engineer & maintainer.
+
+Enspirit (https://enspirit.be) and Klaro App (https://klaro.cards) are both
+actively using and contributing to the library.
+
+Feel free to contact us for help, ideas and/or contributions. Please use github
+issues and pull requests if possible if code is involved.

data/lib/bmg.rb

@@ -38,11 +38,13 @@ module Bmg
   require_relative 'bmg/operator'
 
   require_relative 'bmg/reader'
+  require_relative 'bmg/writer'
 
   require_relative 'bmg/relation/empty'
   require_relative 'bmg/relation/in_memory'
   require_relative 'bmg/relation/spied'
   require_relative 'bmg/relation/materialized'
+  require_relative 'bmg/relation/proxy'
 
   # Deprecated
   Leaf = Relation::InMemory

data/lib/bmg/algebra.rb

@@ -172,6 +172,16 @@ module Bmg
     end
     protected :_summarize
 
+    def transform(transformation = nil, options = {}, &proc)
+      transformation, options = proc, (transformation || {}) unless proc.nil?
+      _transform(self.type.transform(transformation, options), transformation, options)
+    end
+
+    def _transform(type, transformation, options)
+      Operator::Transform.new(type, self, transformation, options)
+    end
+    protected :_transform
+
     def union(other, options = {})
       return self if other.is_a?(Relation::Empty)
       _union self.type.union(other.type), other, options

data/lib/bmg/algebra/shortcuts.rb

@@ -37,6 +37,12 @@ module Bmg
         self.join(right.rename(renaming), on.keys)
       end
 
+      def left_join(right, on = [], *args)
+        return super unless on.is_a?(Hash)
+        renaming = Hash[on.map{|k,v| [v,k] }]
+        self.left_join(right.rename(renaming), on.keys, *args)
+      end
+
       def matching(right, on = [])
         return super unless on.is_a?(Hash)
         renaming = Hash[on.map{|k,v| [v,k] }]

data/lib/bmg/operator.rb

@@ -46,4 +46,5 @@ require_relative 'operator/rename'
 require_relative 'operator/restrict'
 require_relative 'operator/rxmatch'
 require_relative 'operator/summarize'
+require_relative 'operator/transform'
 require_relative 'operator/union'

data/lib/bmg/operator/transform.rb

@@ -0,0 +1,57 @@
+module Bmg
+  module Operator
+    #
+    # Transform operator.
+    #
+    # Transforms existing attributes through computations
+    #
+    # Example:
+    #
+    #   [{ a: 1 }] transform { a: ->(t){ t[:a]*2 } } => [{ a: 4 }]
+    #
+    class Transform
+      include Operator::Unary
+
+      DEFAULT_OPTIONS = {}
+
+      def initialize(type, operand, transformation, options = {})
+        @type = type
+        @operand = operand
+        @transformation = transformation
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+    protected
+
+      attr_reader :transformation
+
+    public
+
+      def each
+        t = transformer
+        @operand.each do |tuple|
+          yield t.call(tuple)
+        end
+      end
+
+      def to_ast
+        [ :transform, operand.to_ast, transformation.dup ]
+      end
+
+    protected ### optimization
+
+    protected ### inspect
+
+      def args
+        [ transformation ]
+      end
+
+    private
+
+      def transformer
+        @transformer ||= TupleTransformer.new(transformation)
+      end
+
+    end # class Transform
+  end # module Operator
+end # module Bmg

data/lib/bmg/relation.rb

@@ -105,6 +105,20 @@ module Bmg
       to_a.to_json(*args, &bl)
     end
 
+    # Writes the relation data to CSV.
+    #
+    # `string_or_io` and `options` are what CSV::new itself
+    # recognizes, default options are CSV's.
+    #
+    # When no string_or_io is used, the method uses a string.
+    #
+    # The method always returns the string_or_io.
+    def to_csv(options = {}, string_or_io = nil, preferences = nil)
+      options, string_or_io = {}, options unless options.is_a?(Hash)
+      string_or_io, preferences = nil, string_or_io if string_or_io.is_a?(Hash)
+      Writer::Csv.new(options, preferences).call(self, string_or_io)
+    end
+
     # Converts to an sexpr expression.
     def to_ast
       raise "Bmg is missing a feature!"

data/lib/bmg/relation/proxy.rb

@@ -0,0 +1,63 @@
+module Bmg
+  module Relation
+    #
+    # This module can be used to create typed collection on top
+    # of Bmg relations. Algebra methods will be delegated to the
+    # decorated relation, and results wrapped in a new instance
+    # of the class.
+    #
+    module Proxy
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def method_missing(name, *args, &bl)
+        if @relation.respond_to?(name)
+          res = @relation.send(name, *args, &bl)
+          res.is_a?(Relation) ? _proxy(res) : res
+        else
+          super
+        end
+      end
+
+      def respond_to?(name, *args)
+        @relation.respond_to?(name) || super
+      end
+
+      [
+        :extend
+      ].each do |name|
+        define_method(name) do |*args, &bl|
+          res = @relation.send(name, *args, &bl)
+          res.is_a?(Relation) ? _proxy(res) : res
+        end
+      end
+
+      [
+        :one,
+        :one_or_nil
+      ].each do |meth|
+        define_method(meth) do |*args, &bl|
+          res = @relation.send(meth, *args, &bl)
+          res.nil? ? nil : _proxy_tuple(res)
+        end
+      end
+
+      def to_json(*args, &bl)
+        @relation.to_json(*args, &bl)
+      end
+
+    protected
+
+      def _proxy(relation)
+        self.class.new(relation)
+      end
+
+      def _proxy_tuple(tuple)
+        tuple
+      end
+
+    end # module Proxy
+  end # class Relation
+end # module Bmg

data/lib/bmg/sequel/translator.rb

@@ -41,7 +41,7 @@ module Bmg
         dataset   = apply(sexpr.from_clause)     if sexpr.from_clause
         #
         selection = apply(sexpr.select_list)
-        predicate = apply(sexpr.predicate)       if sexpr.predicate
+        predicate = compile_predicate(sexpr.predicate) if sexpr.predicate
         grouping  = apply(sexpr.group_by_clause) if sexpr.group_by_clause
         order     = apply(sexpr.order_by_clause) if sexpr.order_by_clause
         limit     = apply(sexpr.limit_clause)    if sexpr.limit_clause
@@ -109,12 +109,12 @@ module Bmg
           elsif kind == :inner_join
             options = { qualify: false, table_alias: false }
             ds.join_table(:inner, apply(table), nil, options){|*args|
-              apply(on)
+              compile_predicate(on)
             }
           elsif kind == :left_join
             options = { qualify: false, table_alias: false }
             ds.join_table(:left, apply(table), nil, options){|*args|
-              apply(on)
+              compile_predicate(on)
             }
           else
             raise IllegalArgumentError, "Unrecognized from clause: `#{sexpr}`"
@@ -165,22 +165,35 @@ module Bmg
         sexpr.last
       end
 
+    private
+
+      def dataset(expr)
+        return expr if ::Sequel::Dataset===expr
+        sequel_db[expr]
+      end
+
+      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)
-        apply(sexpr.last)
+        @parent.apply(sexpr.last)
       end
 
       def on_exists(sexpr)
-        apply(sexpr.last).exists
+        @parent.apply(sexpr.last).exists
       end
 
-    private
-
-      def dataset(expr)
-        return expr if ::Sequel::Dataset===expr
-        sequel_db[expr]
-      end
+    end
 
     end # class Translator
   end # module Sequel

data/lib/bmg/sql/nodes/column_name.rb

@@ -15,6 +15,10 @@ module Bmg
         last
       end
 
+      def is_computed?
+        false
+      end
+
       def to_sql(buffer, dialect)
         buffer << dialect.quote_identifier(last)
         buffer

data/lib/bmg/sql/nodes/func_call.rb

@@ -11,6 +11,10 @@ module Bmg
         self[2..-1]
       end
 
+      def is_computed?
+        true
+      end
+
       def to_sql(buffer, dialect)
         buffer << summary_name.upcase << "("
         buffer << func_args.map{|fa| fa.to_sql("", dialect) }.join(', ')

data/lib/bmg/sql/nodes/literal.rb

@@ -8,6 +8,10 @@ module Bmg
         nil
       end
 
+      def is_computed?
+        false
+      end
+
       def to_sql(buffer, dialect)
         to_sql_literal(buffer, last)
         buffer

data/lib/bmg/sql/nodes/qualified_name.rb

@@ -20,6 +20,10 @@ module Bmg
         as_name
       end
 
+      def is_computed?
+        false
+      end
+
       def to_sql(buffer, dialect)
         self[1].to_sql(buffer, dialect)
         buffer << '.'

data/lib/bmg/sql/nodes/select_exp.rb

@@ -27,6 +27,10 @@ module Bmg
         set_quantifier.all?
       end
 
+      def has_computed_attributes?
+        select_list.has_computed_attributes?
+      end
+
       def join?
         from_clause && from_clause.join?
       end

data/lib/bmg/sql/nodes/select_item.rb

@@ -23,6 +23,10 @@ module Bmg
         last.as_name
       end
 
+      def is_computed?
+        left.is_computed?
+      end
+
       def to_sql(buffer, dialect)
         self[1].to_sql(buffer, dialect)
         unless would_be_name == as_name

data/lib/bmg/sql/nodes/select_list.rb

@@ -23,6 +23,10 @@ module Bmg
         Builder::IS_TABLE_DEE == self
       end
 
+      def has_computed_attributes?
+        sexpr_body.any?{|item| item.is_computed? }
+      end
+
       def knows?(as_name)
         find_child{|child| child.as_name == as_name }
       end

data/lib/bmg/sql/nodes/select_star.rb

@@ -11,6 +11,10 @@ module Bmg
         }
       end
 
+      def has_computed_attributes?
+        false
+      end
+
       def to_sql(buffer, dialect)
         last.to_sql(buffer, dialect)
         buffer << DOT << STAR

data/lib/bmg/sql/nodes/summarizer.rb

@@ -11,6 +11,10 @@ module Bmg
         self.last
       end
 
+      def is_computed?
+        true
+      end
+
       def to_sql(buffer, dialect)
         buffer << summary_func.upcase << "("
         summary_expr.to_sql(buffer, dialect)

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

@@ -20,7 +20,7 @@ module Bmg
         end
 
         def on_select_exp(sexpr)
-          if sexpr.group_by_clause
+          if sexpr.group_by_clause || sexpr.has_computed_attributes?
             sexpr = builder.from_self(sexpr)
             call(sexpr)
           else

data/lib/bmg/support.rb

@@ -1,2 +1,4 @@
 require_relative 'support/tuple_algebra'
+require_relative 'support/tuple_transformer'
 require_relative 'support/keys'
+require_relative 'support/output_preferences'

data/lib/bmg/support/keys.rb

@@ -7,6 +7,10 @@ module Bmg
 
   public ## tools
 
+    def select(&bl)
+      Keys.new(@keys.select(&bl), false)
+    end
+
   public ## algebra
 
     def allbut(oldtype, newtype, butlist)

data/lib/bmg/support/output_preferences.rb

@@ -0,0 +1,44 @@
+module Bmg
+  class OutputPreferences
+
+    DEFAULT_PREFS = {
+      attributes_ordering: nil,
+      extra_attributes: :after
+    }
+
+    def initialize(options)
+      @options = DEFAULT_PREFS.merge(options)
+    end
+    attr_reader :options
+
+    def self.dress(arg)
+      return arg if arg.is_a?(OutputPreferences)
+      arg = {} if arg.nil?
+      new(arg)
+    end
+
+    def attributes_ordering
+      options[:attributes_ordering]
+    end
+
+    def extra_attributes
+      options[:extra_attributes]
+    end
+
+    def order_attrlist(attrlist)
+      return attrlist if attributes_ordering.nil?
+      index = Hash[attributes_ordering.each_with_index.to_a]
+      attrlist.sort{|a,b|
+        ai, bi = index[a], index[b]
+        if ai && bi
+          ai <=> bi
+        elsif ai
+          extra_attributes == :after ? -1 : 1
+        else
+          extra_attributes == :after ? 1 : -1
+        end
+      }
+    end
+
+  end # class OutputPreferences
+end # module Bmg

data/lib/bmg/support/tuple_transformer.rb

@@ -0,0 +1,64 @@
+module Bmg
+  class TupleTransformer
+
+    def initialize(transformation)
+      @transformation = transformation
+    end
+
+    def self.new(arg)
+      return arg if arg.is_a?(TupleTransformer)
+      super
+    end
+
+    def call(tuple)
+      transform_tuple(tuple, @transformation)
+    end
+
+    def knows_attrlist?
+      @transformation.is_a?(Hash)
+    end
+
+    def to_attrlist
+      @transformation.keys
+    end
+
+    private
+
+      def transform_tuple(tuple, with)
+        case with
+        when Symbol
+          tuple.each_with_object({}){|(k,v),dup|
+            dup[k] = transform_attr(v, with)
+          }
+        when Proc
+          tuple.each_with_object({}){|(k,v),dup|
+            dup[k] = transform_attr(v, with)
+          }
+        when Hash
+          with.each_with_object(tuple.dup){|(k,v),dup|
+            dup[k] = transform_attr(dup[k], v)
+          }
+        when Array
+          with.inject(tuple){|dup,on|
+            transform_tuple(dup, on)
+          }
+        else
+          raise ArgumentError, "Unexpected transformation `#{with.inspect}`"
+        end
+      end
+
+      def transform_attr(value, with)
+        case with
+        when Symbol
+          value.send(with)
+        when Proc
+          with.call(value)
+        when Hash
+          with[value]
+        else
+          raise ArgumentError, "Unexpected transformation `#{with.inspect}`"
+        end
+      end
+
+  end # module TupleTransformer
+end # module Bmg

data/lib/bmg/type.rb

@@ -241,6 +241,31 @@ module Bmg
       }
     end
 
+    def transform(transformation, options = {})
+      transformer = TupleTransformer.new(transformation)
+      if typechecked? && knows_attrlist? && transformer.knows_attrlist?
+        known_attributes!(transformer.to_attrlist)
+      end
+      keys = if options[:key_preserving]
+        self._keys
+      elsif transformer.knows_attrlist? && knows_keys?
+        touched_attrs = transformer.to_attrlist
+        keys = self._keys.select{|k| (k & touched_attrs).empty? }
+      else
+        nil
+      end
+      pred = if transformer.knows_attrlist?
+        attr_list = transformer.to_attrlist
+        predicate.and_split(attr_list).last
+      else
+        Predicate.tautology
+      end
+      dup.tap{|x|
+        x.keys = keys
+        x.predicate = pred
+      }
+    end
+
     def union(other)
       if typechecked? && knows_attrlist? && other.knows_attrlist?
         missing = self.attrlist - other.attrlist

data/lib/bmg/version.rb

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

data/lib/bmg/writer.rb

@@ -0,0 +1 @@
+require_relative 'writer/csv'

data/lib/bmg/writer/csv.rb

@@ -0,0 +1,42 @@
+module Bmg
+  module Writer
+    class Csv
+      include Writer
+
+      DEFAULT_OPTIONS = {
+      }
+
+      def initialize(csv_options, output_preferences = nil)
+        @csv_options = DEFAULT_OPTIONS.merge(csv_options)
+        @output_preferences = OutputPreferences.dress(output_preferences)
+      end
+      attr_reader :csv_options, :output_preferences
+
+      def call(relation, string_or_io = nil)
+        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
+        relation.each do |tuple|
+          if csv.nil?
+            headers = infer_headers(tuple) if headers.nil?
+            csv = CSV.new(string_or_io, csv_options.merge(headers: headers))
+          end
+          csv << headers.map{|h| tuple[h] }
+        end
+        to_s ? string_or_io.string : string_or_io
+      end
+
+    private
+
+      def infer_headers(from)
+        attrlist = if from.is_a?(Type) && from.knows_attrlist?
+          from.to_attrlist
+        elsif from.is_a?(Hash)
+          from.keys
+        end
+        attrlist ? output_preferences.order_attrlist(attrlist) : nil
+      end
+
+    end # class Csv
+  end # module Writer
+end # module Bmg

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.17.3
+  version: 0.17.8
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-09 00:00:00.000000000 Z
+date: 2020-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -16,62 +16,62 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.3
+        version: 2.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.3
+        version: 2.4.0
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: path
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
-  type: :development
+        version: '1.3'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '13'
 - !ruby/object:Gem::Dependency
-  name: path
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: roo
   requirement: !ruby/object:Gem::Requirement
@@ -149,6 +149,7 @@ files:
 - lib/bmg/operator/shared/nary.rb
 - lib/bmg/operator/shared/unary.rb
 - lib/bmg/operator/summarize.rb
+- lib/bmg/operator/transform.rb
 - lib/bmg/operator/union.rb
 - lib/bmg/reader.rb
 - lib/bmg/reader/csv.rb
@@ -157,6 +158,7 @@ files:
 - lib/bmg/relation/empty.rb
 - lib/bmg/relation/in_memory.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
@@ -258,9 +260,13 @@ files:
 - lib/bmg/summarizer/variance.rb
 - lib/bmg/support.rb
 - lib/bmg/support/keys.rb
+- lib/bmg/support/output_preferences.rb
 - lib/bmg/support/tuple_algebra.rb
+- lib/bmg/support/tuple_transformer.rb
 - lib/bmg/type.rb
 - lib/bmg/version.rb
+- lib/bmg/writer.rb
+- lib/bmg/writer/csv.rb
 - tasks/gem.rake
 - tasks/test.rake
 homepage: http://github.com/enspirit/bmg