bmg 0.22.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be420623e04afe03570a1756d1607a202eb96481
-  data.tar.gz: 150b4f3f4daced5825e661765ed4530455263422
+  metadata.gz: 542c4218634ee7ae5b224400ee07ec6d2998473a
+  data.tar.gz: 37eddfc05f9fcfca90e96c50fc6628a09cdf8742
 SHA512:
-  metadata.gz: 5b2d86803d1bfedfa5605f158a34c744e8b0fa77ed25314e38a28dac6bdef1512bc51a3398cfcd55df42fb60354880b4378b49d339682724cd3da42ef282ef27
-  data.tar.gz: 7321a2b290d2852ff4e2fe52b915e190d3fb13143807e8ac062928c8745a330d70c43fcbbf4abb545507cc8d2b9a05167502c44c7b6d5310c24b2e781920f827
+  metadata.gz: 9c5009a14fa10be21fc6d76e23fb47a8e0e69e9dd300478822c6bc9758230ff593cb0a3783b94b0a64c4afbd82456b362ee081a02e4a049c65759c9699a3f074
+  data.tar.gz: 5d73d4dad1eb72f3794cbcfddab422e01a197d9c128f6991243cf7d381e41f9ae0cf255f03aff5eb23ac3d4375de1da1345503e086ff01253dd6e636497727b4

data/README.md

@@ -1,6 +1,6 @@
-# Bmg, a relational algebra (Alf's successor)!
+# Bmg, a relational algebra
 
-Bmg is a relational algebra implemented as a Ruby library. It implements the
+Bmg is a [relational algebra](https://www.relational-algebra.dev/) implemented as a Ruby library. It implements the
 [Relation as First-Class Citizen](http://www.try-alf.org/blog/2013-10-21-relations-as-first-class-citizen)
 paradigm contributed with [Alf](http://www.try-alf.org/) a few years ago.
 
@@ -9,16 +9,24 @@ and any data source that can be seen as serving relations. Cross data-sources
 joins are supported, as with Alf. For differences with Alf, see a section
 further down this README.
 
+## Links
+
+* Documentation can be found at https://www.relational-algebra.dev/
+* Contribute to that documentation on github: https://github.com/enspirit/bmg-website
+
 ## Outline
 
 * [Example](#example)
 * [Where are base relations coming from?](#where-are-base-relations-coming-from)
   * [Memory relations](#memory-relations)
   * [Connecting to SQL databases](#connecting-to-sql-databases)
-  * [Reading files (csv, Excel, text)](#reading-files-csv-excel-text)
+  * [Reading data files](#reading-data-files-json-csv-yaml-text-xls--xlsx)
   * [Connecting to Redis databases](#connecting-to-redis-databases)
   * [Your own relations](#your-own-relations)
+* [The Database abstraction](#the-database-abstraction)
 * [List of supported operators](#supported-operators)
+* [List of supported predicates](#supported-predicates)
+* [List of supported summaries](#supported-summaries)
 * [How is this different?](#how-is-this-different)
   * [... from similar libraries](#-from-similar-libraries)
   * [... from Alf](#-from-alf)
@@ -117,33 +125,38 @@ Bmg.sequel(:suppliers, sequel_db)
 #   {:array=>false})
 ```
 
-### Reading files (csv, Excel, text)
+### Reading data files (json, csv, yaml, text, xls & xlsx)
 
 Bmg provides simple adapters to read files and reach Relationland as soon as
 possible.
 
-#### CSV files
+#### JSON files
 
 ```ruby
-csv_options = { col_sep: ",", quote_char: '"' }
-r = Bmg.csv("path/to/a/file.csv", csv_options)
+r = Bmg.json("path/to/a/file.json")
 ```
 
-Options are directly transmitted to `::CSV.new`, check Ruby's standard
-library.
+The json file is expected to contain tuples of same heading.
 
-#### Excel files
+#### YAML files
 
-You will need to add [`roo`](https://github.com/roo-rb/roo) to your Gemfile to
-read `.xls` and `.xlsx` files with Bmg.
+```ruby
+r = Bmg.yaml("path/to/a/file.yaml")
+```
+
+The yaml file is expected to contain tuples of same heading.
+
+#### CSV files
 
 ```ruby
-roo_options = { skip: 1 }
-r = Bmg.excel("path/to/a/file.xls", roo_options)
+csv_options = { col_sep: ",", quote_char: '"' }
+r = Bmg.csv("path/to/a/file.csv", csv_options)
 ```
 
-Options are directly transmitted to `Roo::Spreadsheet.open`, check roo's
-documentation.
+Options are directly transmitted to `::CSV.new`, check Ruby's standard
+library. If you don't provide them, `Bmg` uses `headers: true` (hence making
+then assumption that attributes names are provided on first line), and makes a
+best effort to infer the column separator.
 
 #### Text files
 
@@ -173,6 +186,19 @@ 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).
 
+#### Excel files
+
+You will need to add [`roo`](https://github.com/roo-rb/roo) to your Gemfile to
+read `.xls` and `.xlsx` files with Bmg.
+
+```ruby
+roo_options = { skip: 1 }
+r = Bmg.excel("path/to/a/file.xls", roo_options)
+```
+
+Options are directly transmitted to `Roo::Spreadsheet.open`, check roo's
+documentation.
+
 ### Connecting to Redis databases
 
 Bmg currently requires `bmg-redis` and `redis >= 4.6` to connect
@@ -240,6 +266,58 @@ restrictions down the tree) by overriding the underscored version of operators
 Have a look at `Bmg::Algebra` for the protocol and `Bmg::Sql::Relation` for an
 example. Keep in touch with the team if you need some help.
 
+## The Database abstraction
+
+The previous section focused on obtaining *relations*. In practice you frequently
+have a collection of relations hence a *database*:
+
+* A SQL database with multiple tables
+* A list of data files, all in the same folder
+* An excel file with various sheets
+
+Bmg supports a simple Datbabase abstraction that serves those relations "by name",
+in a simple way. A database can also be easily dumped back to a data folder of
+json or csv files, or as simple xlsx files with multiple sheets.
+
+### Connecting to a SQL Database
+
+For a SQL database, connected with Sequel:
+
+```
+db = Bmg::Database.sequel(Sequel.connect('...'))
+db.suppliers # yields a Bmg::Relation over the `suppliers` table
+```
+
+### Connecting to data files in the same folder
+
+Data files all in the same folder can be seen as a very basic form of database,
+and served as such. Bmg supports `json`, `csv` and `yaml` files:
+
+```
+db = Bmg::Database.data_folder('./my-database')
+db.suppliers # yields a Bmg::Relation over the `suppliers.(json,csv,yml)` file
+```
+
+Bmg supports files in different formats in the same folder. When files with the
+same basename exist, json is prefered over yaml, which is prefered over csv.
+
+### Dumping a Database instance
+
+As a data folder:
+
+```
+db = Bmg::Database.sequel(Sequel.connect('...'))
+db.to_data_folder('path/to/folder', :json)
+```
+
+As an .xlsx file (any existing file will be erased, we don't support modifying
+existing files):
+
+```
+require 'bmg/xlsx'
+db.to_xlsx('path/to/file.xlsx')
+```
+
 ## Supported operators
 
 ```ruby
@@ -283,6 +361,67 @@ r.unwrap(:a)                                 # shortcut over unwrap([:a])
 r.where(predicate)                           # alias for restrict(predicate)
 ```
 
+## Supported Predicates
+
+Usual operators are supported and map to their SQL equivalent as expected:
+
+```ruby
+Predicate.eq                                 # =
+Predicate.neq                                # <>
+Predicate.lt                                 # <
+Predicate.lte                                # <=
+Predicate.gt                                 # >
+Predicate.gte                                # >=
+Predicate.in                                 # SQL's IN
+Predicate.is_null                            # SQL's IS NULL
+```
+
+See the [Predicate gem](https://github.com/enspirit/predicate) for a more
+complete list.
+
+Note: predicates that implement specific Ruby algorithms or patterns are
+not compiled to SQL (and more generally not delegated to underlying database
+servers).
+
+## Supported Summaries
+
+The `summarize` operator receives a list of `attr: summarizer` pairs, e.g.
+
+```ruby
+r.summarize([:city], {
+  how_many: :count,        # same as how_many: Bmg::Summarizer.count
+  status: :max,            # same as   status: Bmg::Summarizer.max(:status)
+  min_status: Bmg::Summarizer.min(:status)
+})
+```
+
+The following summarizers are available and translated to SQL:
+
+```ruby
+Bmg::Summarizer.count                      # count the number of tuples
+Bmg::Summarizer.distinct(:a)               # collect distinct values (as an array)
+Bmg::Summarizer.distinct_count(:a)         # count of distinct values
+Bmg::Summarizer.min(:a)                    # min value for attribute :a
+Bmg::Summarizer.max(:a)                    # max value
+Bmg::Summarizer.sum(:a)                    # sum :a's values
+Bmg::Summarizer.avg(:a)                    # average
+```
+
+The following summarizers are implemented in Ruby (they are supported when
+querying SQL databases, but not compiled to SQL):
+
+```ruby
+Bmg::Summarizer.collect(:a)                # collect :a's values (as an array)
+Bmg::Summarizer.concat(:a, opts: { ... })  # concat :a's values (opts, e.g. {between: ','})
+Bmg::Summarizer.first(:a, order: ...)      # smallest seen a:'s value according to a tuple ordering
+Bmg::Summarizer.last(:a, order: ...)       # largest seen a:'s value according to a tuple ordering
+Bmg::Summarizer.variance(:a)               # variance
+Bmg::Summarizer.stddev(:a)                 # standard deviation
+Bmg::Summarizer.percentile(:a, nth)        # (continuous) nth percentile
+Bmg::Summarizer.percentile_disc(:a, nth)   # discrete nth percentile
+Bmg::Summarizer.value_by(:a, :by => :b)    # { :b => :a } as a Hash
+```
+
 ## How is this different?
 
 ### ... from similar libraries?

data/lib/bmg/database/data_folder.rb

@@ -0,0 +1,67 @@
+module Bmg
+  class Database
+    class DataFolder < Database
+
+      DEFAULT_OPTIONS = {
+        data_extensions: ['json', 'yml', 'yaml', 'csv']
+      }
+
+      def initialize(folder, options = {})
+        @folder = Path(folder)
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      def method_missing(name, *args, &bl)
+        return super(name, *args, &bl) unless args.empty? && bl.nil?
+        raise NotSuchRelationError(name.to_s) unless file = find_file(name)
+        read_file(file)
+      end
+
+      def each_relation_pair
+        return to_enum(:each_relation_pair) unless block_given?
+
+        @folder.glob('*') do |path|
+          next unless path.file?
+          next unless @options[:data_extensions].find {|ext|
+            path.ext == ".#{ext}" || path.ext == ext
+          }
+          yield(path.basename.rm_ext.to_sym, read_file(path))
+        end
+      end
+
+      def self.dump(database, path, ext = :json)
+        path = Path(path)
+        path.mkdir_p
+        database.each_relation_pair do |name, rel|
+          (path/"#{name}.#{ext}").write(rel.public_send(:"to_#{ext}"))
+        end
+        path
+      end
+
+    private
+
+      def read_file(file)
+        case file.ext.to_s
+        when '.json'
+          Bmg.json(file)
+        when '.yaml', '.yml'
+          Bmg.yaml(file)
+        when '.csv'
+          Bmg.csv(file)
+        else
+          raise NotSupportedError, "Unable to use #{file} as a relation"
+        end
+      end
+
+      def find_file(name)
+        exts = @options[:data_extensions]
+        exts.each do |ext|
+          target = @folder/"#{name}.#{ext}"
+          return target if target.file?
+        end
+        raise NotSuchRelationError, "#{@folder}/#{name}.#{exts.join(',')}"
+      end
+
+    end # class DataFolder
+  end # class Database
+end # module Bmg

data/lib/bmg/database/sequel.rb

@@ -0,0 +1,35 @@
+module Bmg
+  class Database
+    class Sequel < Database
+
+      DEFAULT_OPTIONS = {
+      }
+
+      def initialize(sequel_db, options = {})
+        @sequel_db = sequel_db
+        @sequel_db = ::Sequel.connect(@sequel_db) unless @sequel_db.is_a?(::Sequel::Database)
+      end
+
+      def method_missing(name, *args, &bl)
+        return super(name, *args, &bl) unless args.empty? && bl.nil?
+        raise NotSuchRelationError(name.to_s) unless @sequel_db.table_exists?(name)
+        rel_for(name)
+      end
+
+      def each_relation_pair
+        return to_enum(:each_relation_pair) unless block_given?
+
+        @sequel_db.tables.each do |table|
+          yield(table, rel_for(table))
+        end
+      end
+
+    protected
+
+      def rel_for(table_name)
+        Bmg.sequel(table_name, @sequel_db)
+      end
+
+    end # class Sequel
+  end # class Database
+end # module Bmg

data/lib/bmg/database/xlsx.rb

@@ -0,0 +1,41 @@
+module Bmg
+  class Database
+    class Xlsx < Database
+
+      DEFAULT_OPTIONS = {
+      }
+
+      def initialize(path, options = {})
+        path = Path(path) if path.is_a?(String)
+        @path = path
+        @options = options.merge(DEFAULT_OPTIONS)
+      end
+
+      def method_missing(name, *args, &bl)
+        return super(name, *args, &bl) unless args.empty? && bl.nil?
+        rel = rel_for(name)
+        raise NotSuchRelationError(name.to_s) unless rel
+        rel
+      end
+
+      def each_relation_pair
+        return to_enum(:each_relation_pair) unless block_given?
+
+        spreadsheet.sheets.each do |sheet_name|
+          yield(sheet_name.to_sym, rel_for(sheet_name))
+        end
+      end
+
+    protected
+
+      def spreadsheet
+        @spreadsheet ||= Roo::Spreadsheet.open(@path, @options)
+      end
+
+      def rel_for(sheet_name)
+        Bmg.excel(@path, { sheet: sheet_name.to_s })
+      end
+
+    end # class Sequel
+  end # class Database
+end # module Bmg

data/lib/bmg/database.rb

@@ -0,0 +1,35 @@
+module Bmg
+  class Database
+
+    def self.data_folder(*args)
+      require_relative 'database/data_folder'
+      DataFolder.new(*args)
+    end
+
+    def self.sequel(*args)
+      require 'bmg/sequel'
+      require_relative 'database/sequel'
+      Sequel.new(*args)
+    end
+
+    def self.xlsx(*args)
+      require 'bmg/xlsx'
+      require_relative 'database/xlsx'
+      Xlsx.new(*args)
+    end
+
+    def to_xlsx(*args)
+      require 'bmg/xlsx'
+      Writer::Xlsx.to_xlsx(self, *args)
+    end
+
+    def to_data_folder(*args)
+      DataFolder.dump(self, *args)
+    end
+
+    def each_relation_pair
+      raise NotImplementedError
+    end
+
+  end # class Database
+end # module Bmg

data/lib/bmg/error.rb

@@ -23,4 +23,7 @@ module Bmg
   # to backtrack to something more ruby-native.
   class NotSupportedError < Error; end
 
+  # Raised when relation (variable) is not found
+  class NotSuchRelationError < Error; end
+
 end

data/lib/bmg/reader/excel.rb

@@ -1,80 +1 @@
-module Bmg
-  module Reader
-    class Excel
-      include Reader
-
-      DEFAULT_OPTIONS = {
-        sheet: 0,
-        skip: 0,
-        row_num: true
-      }
-
-      def initialize(type, path, options = {})
-        require 'roo'
-        @path = path
-        @options = DEFAULT_OPTIONS.merge(options)
-        @type = type.knows_attrlist? ? type : type.with_attrlist(infer_attrlist)
-      end
-
-      def each
-        return to_enum unless block_given?
-
-        headers = type.attrlist
-        headers = headers[1..-1] if generate_row_num?
-        start_at = @options[:skip] + 2
-        end_at = spreadsheet.last_row
-        (start_at..end_at).each do |i|
-          row = spreadsheet.row(i)
-          init = init_tuple(i - start_at + 1)
-          tuple = (0...headers.size).each_with_object(init){|i,t|
-            t[headers[i]] = row[i]
-          }
-          yield(tuple)
-        end
-      end
-
-      def to_ast
-        [ :excel, @path, @options ]
-      end
-
-      def to_s
-        "(excel #{@path})"
-      end
-      alias :inspect :to_s
-
-    private
-
-      def spreadsheet
-        @spreadsheet ||= Roo::Spreadsheet
-          .open(@path, @options)
-          .sheet(@options[:sheet])
-      end
-
-      def infer_attrlist
-        row = spreadsheet.row(1+@options[:skip])
-        attrlist = row.map{|c| c.to_s.strip.to_sym }
-        attrlist.unshift(row_num_name) if generate_row_num?
-        attrlist
-      end
-
-      def generate_row_num?
-        !!@options[:row_num]
-      end
-
-      def row_num_name
-        case as = @options[:row_num]
-        when TrueClass  then :row_num
-        when Symbol     then as
-        else nil
-        end
-      end
-
-      def init_tuple(i)
-        return {} unless generate_row_num?
-
-        { row_num_name => i }
-      end
-
-    end # class Excel
-  end # module Reader
-end # module Bmg
+require_relative 'xlsx'

data/lib/bmg/reader/xlsx.rb

@@ -0,0 +1,80 @@
+module Bmg
+  module Reader
+    class Excel
+      include Reader
+
+      DEFAULT_OPTIONS = {
+        sheet: 0,
+        skip: 0,
+        row_num: true
+      }
+
+      def initialize(type, path, options = {})
+        require 'roo'
+        @path = path
+        @options = DEFAULT_OPTIONS.merge(options)
+        @type = type.knows_attrlist? ? type : type.with_attrlist(infer_attrlist)
+      end
+
+      def each
+        return to_enum unless block_given?
+
+        headers = type.attrlist
+        headers = headers[1..-1] if generate_row_num?
+        start_at = @options[:skip] + 2
+        end_at = spreadsheet.last_row
+        (start_at..end_at).each do |i|
+          row = spreadsheet.row(i)
+          init = init_tuple(i - start_at + 1)
+          tuple = (0...headers.size).each_with_object(init){|i,t|
+            t[headers[i]] = row[i]
+          }
+          yield(tuple)
+        end
+      end
+
+      def to_ast
+        [ :excel, @path, @options ]
+      end
+
+      def to_s
+        "(excel #{@path})"
+      end
+      alias :inspect :to_s
+
+    private
+
+      def spreadsheet
+        @spreadsheet ||= Roo::Spreadsheet
+          .open(@path, @options)
+          .sheet(@options[:sheet])
+      end
+
+      def infer_attrlist
+        row = spreadsheet.row(1+@options[:skip])
+        attrlist = row.map{|c| c.to_s.strip.to_sym }
+        attrlist.unshift(row_num_name) if generate_row_num?
+        attrlist
+      end
+
+      def generate_row_num?
+        !!@options[:row_num]
+      end
+
+      def row_num_name
+        case as = @options[:row_num]
+        when TrueClass  then :row_num
+        when Symbol     then as
+        else nil
+        end
+      end
+
+      def init_tuple(i)
+        return {} unless generate_row_num?
+
+        { row_num_name => i }
+      end
+
+    end # class Excel
+  end # module Reader
+end # module Bmg

data/lib/bmg/sequel.rb

@@ -1,3 +1,4 @@
+require 'bmg'
 require 'bmg/sql'
 require 'sequel'
 require 'predicate/sequel'

data/lib/bmg/summarizer/bucketize.rb

@@ -0,0 +1,82 @@
+module Bmg
+  class Summarizer
+    #
+    # Bucketizer summarizer.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.bucketize(:qty, :size => 2).summarize(...)
+    #
+    class Bucketize < Summarizer
+
+      # Sets default options.
+      def default_options
+        { :size => 10 }
+      end
+
+      # Returns least value (defaults to "")
+      def least()
+        [[], []]
+      end
+
+      # Concatenates current memo with val.to_s
+      def _happens(memo, val)
+        memo.first << val
+        memo
+      end
+
+      # Finalizes computation
+      def finalize(memo)
+        buckets = compute_buckets(memo.first, options[:size])
+        buckets = touching_buckets(buckets) if options[:boundaries] == :touching
+        buckets
+      end
+
+    private
+
+      def compute_buckets(values, num_buckets = 10)
+        sorted_values = values.compact.sort
+        sorted_values = sorted_values.map{|v| v.to_s[0...options[:value_length]] } if options[:value_length]
+        sorted_values = sorted_values.uniq if options[:distinct]
+
+        # Calculate the size of each bucket
+        total_values = sorted_values.length
+        bucket_size = (total_values / num_buckets.to_f).ceil
+
+        # Create the ranges for each bucket
+        bucket_ranges = []
+        num_buckets.times do |i|
+          start_index = i * bucket_size
+          break if start_index >= total_values  # Ensure we do not exceed the array bounds
+
+          end_index = [(start_index + bucket_size - 1), total_values - 1].min
+          start_value = sorted_values[start_index]
+          end_value = sorted_values[end_index]
+          bucket_ranges << (start_value..end_value)
+        end
+
+        bucket_ranges
+      end
+
+      def touching_buckets(buckets)
+        result = []
+        buckets.each do |b|
+          r_start = result.empty? ? b.begin : result.last.end
+          r_end = b.end
+          result << (r_start...r_end)
+        end
+        result[-1] = (result.last.begin..result.last.end)
+
+        result
+      end
+
+    end # class Concat
+
+    # Factors a bucketize summarizer
+    def self.bucketize(*args, &bl)
+      Bucketize.new(*args, &bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/concat.rb

@@ -21,7 +21,7 @@ module Bmg
       end
 
       # Concatenates current memo with val.to_s
-      def _happens(memo, val) 
+      def _happens(memo, val)
         memo << options[:between].to_s unless memo.empty?
         memo << val.to_s
       end

data/lib/bmg/summarizer.rb

@@ -172,3 +172,4 @@ require_relative 'summarizer/value_by'
 require_relative 'summarizer/positional'
 require_relative 'summarizer/first'
 require_relative 'summarizer/last'
+require_relative 'summarizer/bucketize'

data/lib/bmg/version.rb

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

data/lib/bmg/writer/xlsx.rb

@@ -7,22 +7,36 @@ module Bmg
       }
 
       def initialize(xlsx_options, output_preferences = nil)
+        require 'write_xlsx'
         @xlsx_options = DEFAULT_OPTIONS.merge(xlsx_options)
         @output_preferences = OutputPreferences.dress(output_preferences)
       end
       attr_reader :xlsx_options, :output_preferences
 
       def call(relation, path)
-        require 'write_xlsx'
         dup._call(relation, path)
       end
 
+      def self.to_xlsx(database, path)
+        require 'write_xlsx'
+        workbook = WriteXLSX.new(path)
+        database.each_relation_pair do |name, rel|
+          worksheet = workbook.add_worksheet(name)
+          rel.to_xlsx({
+            workbook: workbook,
+            worksheet: worksheet,
+          })
+        end
+        workbook.close
+      end
+
     protected
       attr_reader :workbook, :worksheet
 
       def _call(relation, path)
         @workbook = xlsx_options[:workbook] || WriteXLSX.new(path)
         @worksheet = xlsx_options[:worksheet] || workbook.add_worksheet
+        @worksheet = workbook.add_worksheet(@worksheet) if @worksheet.is_a?(String)
 
         headers = infer_headers(relation.type)
         before = nil

data/lib/bmg/xlsx.rb

@@ -0,0 +1,3 @@
+require_relative 'reader/xlsx'
+require_relative 'writer/xlsx'
+require_relative 'database/xlsx'

data/lib/bmg.rb

@@ -24,6 +24,16 @@ module Bmg
   end
   module_function :csv
 
+  def json(path, options = {}, type = Type::ANY)
+    in_memory(path.load.map{|tuple| TupleAlgebra.symbolize_keys(tuple) })
+  end
+  module_function :json
+
+  def yaml(path, options = {}, type = Type::ANY)
+    in_memory(path.load.map{|tuple| TupleAlgebra.symbolize_keys(tuple) })
+  end
+  module_function :yaml
+
   def excel(path, options = {}, type = Type::ANY)
     Reader::Excel.new(type, path, options).spied(main_spy)
   end
@@ -57,6 +67,8 @@ module Bmg
   require_relative 'bmg/relation/materialized'
   require_relative 'bmg/relation/proxy'
 
+  require_relative 'bmg/database'
+
   # Deprecated
   Leaf = Relation::InMemory
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.23.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-17 00:00:00.000000000 Z
+date: 2024-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -142,6 +142,10 @@ files:
 - lib/bmg.rb
 - lib/bmg/algebra.rb
 - lib/bmg/algebra/shortcuts.rb
+- lib/bmg/database.rb
+- lib/bmg/database/data_folder.rb
+- lib/bmg/database/sequel.rb
+- lib/bmg/database/xlsx.rb
 - lib/bmg/error.rb
 - lib/bmg/operator.rb
 - lib/bmg/operator/allbut.rb
@@ -172,6 +176,7 @@ files:
 - lib/bmg/reader/csv.rb
 - lib/bmg/reader/excel.rb
 - lib/bmg/reader/text_file.rb
+- lib/bmg/reader/xlsx.rb
 - lib/bmg/relation.rb
 - lib/bmg/relation/empty.rb
 - lib/bmg/relation/in_memory.rb
@@ -272,6 +277,7 @@ files:
 - lib/bmg/sql/version.rb
 - lib/bmg/summarizer.rb
 - lib/bmg/summarizer/avg.rb
+- lib/bmg/summarizer/bucketize.rb
 - lib/bmg/summarizer/by_proc.rb
 - lib/bmg/summarizer/collect.rb
 - lib/bmg/summarizer/concat.rb
@@ -300,6 +306,7 @@ files:
 - lib/bmg/writer.rb
 - lib/bmg/writer/csv.rb
 - lib/bmg/writer/xlsx.rb
+- lib/bmg/xlsx.rb
 - tasks/gem.rake
 - tasks/test.rake
 homepage: http://github.com/enspirit/bmg