bmg 0.16.7 → 0.17.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ca0b8ab7a34fca3dbf7cb37774b099289a8e15cf42fd381b9ee88f3ac01ff81
-  data.tar.gz: e96b6905b920b0cf70e52227ffe19dcd40ce3a9263deadf032a628348f4c340c
+  metadata.gz: 1e48d4a2d3c4bea8271e40ad4db52f43438de7f754079cc4c5bcd5e98ce4865d
+  data.tar.gz: 3fff9f251a2b766ab3de631748ccc6fe6f6b96ccef88507cb3ed76766fea3992
 SHA512:
-  metadata.gz: 6727a3c5b475e5a69765b0f2d4093df4f2aa2ee67364589ee8c0a8e3d368acf50cbe092e7651791e3b13f70ee4d51718921166cac62595998f0b0de2775b1b54
-  data.tar.gz: ef2c1b8eb520f5a4a3a7a24a95f7afcbb96be47e77872dbd55100a0369bd65d7c4d173234d4966591a803106b4937505c5d36ab8ee59d8fde2d6c261988e3ab8
+  metadata.gz: facfbb798258cfdec3803cc7b93999d23c8a0776ead53c074266f4f658a27feee1a3e1dcc1145e7ad45bb03579d22f5d65108152516ac0af0d79aa59805ee016
+  data.tar.gz: 10271e608276bc2e00ccee3d6a94287cb2211d945898cb9cfa54764a05027c9e6a6c34a11e9725f9ed47df4df537fe054d8c3f17b24f58da9713761121523e73

data/Gemfile

@@ -1,2 +1,5 @@
 source "https://rubygems.org"
 gemspec
+
+# gem "predicate", github: "enspirit/predicate", branch: "placeholders"
+# gem "predicate", path: "../predicate"

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
@@ -80,3 +134,13 @@ r.summarize([:a, :b, ...], x: :sum)          # relational summarization
 r.suffix(:_foo, but: [:a, ...])              # suffix kind of renaming
 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/algebra.rb

@@ -80,6 +80,19 @@ module Bmg
     end
     protected :_joined_with
 
+    def left_join(right, on = [], default_right_tuple = {})
+      drt = default_right_tuple
+      _left_join self.type.left_join(right.type, on, drt), right, on, drt
+    end
+
+    def _left_join(type, right, on, default_right_tuple)
+      Operator::Join.new(type, self, right, on, {
+        variant: :left,
+        default_right_tuple: default_right_tuple
+      })
+    end
+    protected :_left_join
+
     def matching(right, on = [])
       _matching self.type.matching(right.type, on), right, on
     end

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/image.rb

@@ -12,7 +12,21 @@ module Bmg
 
         # Whether we need to convert each image as an Array,
         # instead of keeping a Relation instance
-        array: false
+        array: false,
+
+        # The strategy to use for actual image algorithm. Default is
+        # :refilter_right. Possible values are:
+        #
+        # - :index_right : builds a memory index with tuples from right, then
+        #   passes left tuples and joins them with the index values.
+        #
+        # - :refilter_right : the left operand is materialized and all
+        #   distinct values collected. The right operand is lately restricted
+        #   to only those matching values. :index_right is then applied on
+        #   resulting operabds. This option only applies when (optimized) `on`
+        #   contains one attribute only. ; it fallbacks on :index_right
+        #   otherwise.
+        strategy: :refilter_right
 
       }
 
@@ -31,7 +45,55 @@ module Bmg
 
     public
 
-      def each
+      def each(*args, &bl)
+        (options[:jit_optimized] ? self : jit_optimize)._each(*args, &bl)
+      end
+
+      def to_ast
+        [ :image, left.to_ast, right.to_ast, as, on, options.dup ]
+      end
+
+    protected
+
+      def _each(*args, &bl)
+        case s = options[:strategy]
+        when :index_right then _each_index_right(*args, &bl)
+        when :refilter_right then _each_refilter_right(*args, &bl)
+        else
+          raise ArgumentError, "Unknown strategy `#{s}`"
+        end
+      end
+
+      def _each_index_right(*args, &bl)
+        left_rel, right_rel = self.left, self.right
+        _each_implem(left_rel, right_rel, *args, &bl)
+      end
+
+      def _each_refilter_right(*args, &bl)
+        left_rel, right_rel = self.left, self.right
+
+        # find matching keys on left and rebind the right
+        # placeholder to them
+        values = left_rel.map{|t| t[on.first] }
+        placeholder = options[:refilter_right][:placeholder]
+        right_rel = right_rel.bind(placeholder => values)
+
+        _each_implem(left_rel, right_rel, *args, &bl)
+      end
+
+      def _each_implem(left_rel, right_rel, *args)
+        # build right index
+        index = build_right_index(right_rel)
+
+        # each left with image from right index
+        left_rel.each do |tuple|
+          key = tuple_project(tuple, on)
+          image = index[key] || (options[:array] ? [] : empty_image)
+          yield tuple.merge(as => image)
+        end
+      end
+
+      def build_right_index(right)
         index = Hash.new{|h,k| h[k] = empty_image }
         right.each_with_object(index) do |t, index|
           key = tuple_project(t, on)
@@ -42,15 +104,54 @@ module Bmg
             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)
+        index
+      end
+
+    protected ### jit_optimization
+
+      def jit_optimize
+        case s = options[:strategy]
+        when :index_right then jit_index_right
+        when :refilter_right then jit_refilter_right
+        else
+          raise ArgumentError, "Unknown strategy `#{s}`"
         end
       end
 
-      def to_ast
-        [ :image, left.to_ast, right.to_ast, as, on, options.dup ]
+      def jit_index_right
+        Image.new(
+          type,
+          left,
+          right,
+          as,
+          on,
+          options.merge(jit_optimized: true))
+      end
+
+      def jit_refilter_right
+        ltc = left.type.predicate.constants
+        rtc = right.type.predicate.constants
+        jit_allbut, jit_on = on.partition{|attr|
+          ltc.has_key?(attr) && rtc.has_key?(attr) && ltc[attr] == rtc[attr]
+        }
+        if jit_on.size == 1
+          p = Predicate.placeholder
+          Image.new(
+            type,
+            left.materialize,
+            right.restrict(Predicate.in(jit_on.first, p)).allbut(jit_allbut),
+            as,
+            jit_on,
+            options.merge(jit_optimized: true, refilter_right: { placeholder: p }))
+        else
+          Image.new(
+            type,
+            left,
+            right.allbut(jit_allbut),
+            as,
+            jit_on,
+            options.merge(jit_optimized: true, strategy: :index_right))
+        end
       end
 
     protected ### optimization
@@ -68,7 +169,7 @@ module Bmg
       def _restrict(type, predicate)
         on_as, rest = predicate.and_split([as])
         if rest.tautology?
-          # push none situation: on_as is still the full predicate
+          # push index_right situation: on_as is still the full predicate
           super
         else
           # rest makes no reference to `as` and can be pushed
@@ -126,6 +227,16 @@ module Bmg
         Relation::InMemory.new(image_type, Set.new)
       end
 
+    public
+
+      def to_s
+        options[:jit_optimized] ? super : jit_optimize.to_s
+      end
+
+      def inspect
+        options[:jit_optimized] ? super : jit_optimize.inspect
+      end
+
     end # class Project
   end # module Operator
 end # module Bmg

data/lib/bmg/operator/join.rb

@@ -8,16 +8,19 @@ module Bmg
     class Join
       include Operator::Binary
 
-      def initialize(type, left, right, on)
+      DEFAULT_OPTIONS = {}
+
+      def initialize(type, left, right, on, options = {})
         @type = type
         @left = left
         @right = right
         @on = on
+        @options = DEFAULT_OPTIONS.merge(options)
       end
 
     private
 
-      attr_reader :on
+      attr_reader :on, :options
 
     public
 
@@ -34,12 +37,24 @@ module Bmg
             to_join.each do |right|
               yield right.merge(tuple)
             end
+          elsif left_join?
+            yield(tuple.merge(default_right_tuple))
           end
         end
       end
 
       def to_ast
-        [ :join, left.to_ast, right.to_ast, on ]
+        [ :join, left.to_ast, right.to_ast, on, extra_opts ].compact
+      end
+
+    protected
+
+      def left_join?
+        options[:variant] == :left
+      end
+
+      def default_right_tuple
+        options[:default_right_tuple]
       end
 
     protected ### optimization
@@ -63,8 +78,13 @@ module Bmg
 
     protected ### inspect
 
+      def extra_opts
+        extra = options.dup.delete_if{|k,v| DEFAULT_OPTIONS[k] == v }
+        extra.empty? ? nil : extra
+      end
+
       def args
-        [ on ]
+        [ on, extra_opts ].compact
       end
 
     private

data/lib/bmg/operator/restrict.rb

@@ -21,6 +21,10 @@ module Bmg
 
     public
 
+      def bind(binding)
+        Restrict.new(type, operand.bind(binding), predicate.bind(binding))
+      end
+
       def each
         @operand.each do |tuple|
           yield(tuple) if @predicate.evaluate(tuple)

data/lib/bmg/operator/shared/binary.rb

@@ -3,9 +3,13 @@ module Bmg
     module Binary
       include Operator
 
+      def bind(binding)
+        _with_operands(left.bind(binding), right.bind(binding))
+      end
+
     protected
 
-      attr_reader :left, :right
+      attr_accessor :left, :right
 
       def _visit(parent, visitor)
         visitor.call(self, parent)
@@ -13,6 +17,13 @@ module Bmg
         right.send(:_visit, self, visitor)
       end
 
+      def _with_operands(left, right)
+        dup.tap{|d|
+          d.left = left
+          d.right = right
+        }
+      end
+
       def operands
         [left, right]
       end

data/lib/bmg/operator/shared/nary.rb

@@ -3,9 +3,17 @@ module Bmg
     module Nary
       include Operator
 
+      def bind(binding)
+        _with_operands(operands.map{|op| op.bind(binding) })
+      end
+
     protected
 
-      attr_reader :operands
+      attr_accessor :operands
+
+      def _with_operands(operands)
+        dup.tap{|d| d.operands = operands }
+      end
 
       def _visit(parent, visitor)
         visitor.call(self, parent)

data/lib/bmg/operator/shared/unary.rb

@@ -3,15 +3,23 @@ module Bmg
     module Unary
       include Operator
 
+      def bind(binding)
+        _with_operand(operand.bind(binding))
+      end
+
     protected
 
-      attr_reader :operand
+      attr_accessor :operand
 
       def _visit(parent, visitor)
         visitor.call(self, parent)
         operand._visit(self, visitor)
       end
 
+      def _with_operand(operand)
+        dup.tap{|d| d.operand = operand }
+      end
+
       def operands
         [operand]
       end

data/lib/bmg/relation.rb

@@ -13,6 +13,10 @@ module Bmg
       Relation::Empty.new(type)
     end
 
+    def bind(binding)
+      self
+    end
+
     def with_typecheck
       dup.tap{|r|
         r.type = r.type.with_typecheck

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
@@ -70,13 +70,18 @@ module Bmg
         case kind = sexpr.left.first
         when :qualified_name
           left.column == right.value ? left : ::Sequel.as(left, right)
-        when :literal, :summarizer
+        when :literal, :summarizer, :func_call
           ::Sequel.as(left, right)
         else
           raise NotImplementedError, "Unexpected select item `#{kind}`"
         end
       end
 
+      def on_func_call(sexpr)
+        args = sexpr.func_args.map{|fa| apply(fa) }
+        ::Sequel.function(sexpr.func_name, *args)
+      end
+
       def on_summarizer(sexpr)
         if sexpr.summary_expr
           ::Sequel.function(sexpr.summary_func, apply(sexpr.summary_expr))
@@ -104,8 +109,15 @@ 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|
+              compile_predicate(on)
             }
+          else
+            raise IllegalArgumentError, "Unrecognized from clause: `#{sexpr}`"
           end
         end
       end
@@ -153,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/grammar.rb

@@ -42,6 +42,9 @@ require_relative "nodes/with_exp"
 require_relative "nodes/with_spec"
 require_relative "nodes/name_intro"
 require_relative "nodes/where_clause"
+require_relative "nodes/join"
 require_relative "nodes/cross_join"
 require_relative "nodes/inner_join"
+require_relative "nodes/left_join"
 require_relative "nodes/summarizer"
+require_relative "nodes/func_call"

data/lib/bmg/sql/grammar.sexp.yml

@@ -24,10 +24,13 @@ rules:
   join_exp:
     - cross_join
     - inner_join
+    - left_join
   cross_join:
     - [ table_spec, table_spec ]
   inner_join:
     - [ table_spec, table_spec, predicate ]
+  left_join:
+    - [ table_spec, table_spec, predicate ]
   using:
     - [ column_name+ ]
   select_exp:
@@ -76,6 +79,7 @@ rules:
     - qualified_name
     - column_name
     - summarizer
+    - func_call
     - literal
   a_name:
     - qualified_name
@@ -88,6 +92,10 @@ rules:
     - [ summary_func, qualified_name ]
   summary_func:
     - "::Symbol"
+  func_call:
+    - [ func_name, scalar_exp+ ]
+  func_name:
+    - "::Symbol"
   table_name:
     - [ name_rgx ]
   range_var_name:
@@ -96,6 +104,8 @@ rules:
     - [ integer ]
   offset_clause:
     - [ integer ]
+  default_right_tuple:
+    - "::Hash"
   integer:
     - "::Integer"
   literal:

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/cross_join.rb

@@ -2,18 +2,7 @@ module Bmg
   module Sql
     module CrossJoin
       include Expr
-
-      def join?
-        true
-      end
-
-      def left
-        self[1]
-      end
-
-      def right
-        self[2]
-      end
+      include Join
 
       def to_sql(buffer, dialect)
         each_child do |child, index|

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

@@ -0,0 +1,27 @@
+module Bmg
+  module Sql
+    module FuncCall
+      include Expr
+
+      def func_name
+        self[1]
+      end
+
+      def func_args
+        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(', ')
+        buffer << ")"
+        buffer
+      end
+
+    end # module FuncCall
+  end # module Sql
+end # module Bmg

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

@@ -2,34 +2,12 @@ module Bmg
   module Sql
     module InnerJoin
       include Expr
+      include Join
 
       INNER = "INNER".freeze
-      JOIN  = "JOIN".freeze
-      ON    = "ON".freeze
 
-      def join?
-        true
-      end
-
-      def left
-        self[1]
-      end
-
-      def right
-        self[2]
-      end
-
-      def predicate
-        last
-      end
-
-      def to_sql(buffer, dialect)
-        left.to_sql(buffer, dialect)
-        buffer << SPACE << JOIN << SPACE
-        right.to_sql(buffer, dialect)
-        buffer << SPACE << ON << SPACE
-        predicate.to_sql(buffer, dialect)
-        buffer
+      def type
+        INNER
       end
 
     end # module InnerJoin

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

@@ -0,0 +1,44 @@
+module Bmg
+  module Sql
+    module Join
+      include Expr
+
+      JOIN  = "JOIN".freeze
+      ON    = "ON".freeze
+
+      def type
+        nil
+      end
+
+      def join?
+        true
+      end
+
+      def left
+        self[1]
+      end
+
+      def right
+        self[2]
+      end
+
+      def predicate
+        last
+      end
+
+      def to_sql(buffer, dialect)
+        left.to_sql(buffer, dialect)
+        if type.nil?
+          buffer << SPACE << JOIN << SPACE
+        else
+          buffer << SPACE << TYPE << SPACE << JOIN << SPACE
+        end
+        right.to_sql(buffer, dialect)
+        buffer << SPACE << ON << SPACE
+        predicate.to_sql(buffer, dialect)
+        buffer
+      end
+
+    end # module Join
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,15 @@
+module Bmg
+  module Sql
+    module LeftJoin
+      include Expr
+      include Join
+
+      LEFT = "LEFT".freeze
+
+      def type
+        LEFT
+      end
+
+    end # module LeftJoin
+  end # module Sql
+end # module Bmg

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.rb

@@ -85,3 +85,4 @@ require_relative 'processor/semi_join'
 require_relative 'processor/flatten'
 require_relative 'processor/requalify'
 require_relative 'processor/summarize'
+require_relative 'processor/bind'

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

@@ -0,0 +1,23 @@
+module Bmg
+  module Sql
+    class Processor
+      class Bind < Processor
+
+        def initialize(binding, builder)
+          super(builder)
+          @binding = binding
+        end
+
+        def on_select_exp(sexpr)
+          if w = sexpr.where_clause
+            pred = Predicate::Grammar.sexpr(w.predicate.bind(@binding))
+            sexpr.with_update(:where_clause, [ :where_clause, pred ])
+          else
+            sexpr
+          end
+        end
+
+      end # class Bind
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -4,18 +4,19 @@ module Bmg
       class Join < Processor
         include JoinSupport
 
-        def initialize(right, on, builder)
+        def initialize(right, on, options, builder)
           super(builder)
           @right = right
           @on = on
+          @options = options
         end
-        attr_reader :right, :on
+        attr_reader :right, :on, :options
 
         def call(sexpr)
           if unjoinable?(sexpr)
             call(builder.from_self(sexpr))
           elsif unjoinable?(right)
-            Join.new(builder.from_self(right), on, builder).call(sexpr)
+            Join.new(builder.from_self(right), on, options, builder).call(sexpr)
           else
             super(sexpr)
           end
@@ -45,14 +46,21 @@ module Bmg
           left_list, right_list = left.select_list, right.select_list
           list = left_list.dup
           right_list.each_child do |child, index|
-            list << child unless left_list.knows?(child.as_name)
+            next if left_list.knows?(child.as_name)
+            if left_join?
+              list << coalesced(child)
+            else
+              list << child
+            end
           end
           list
         end
 
         def join_from_clauses(left, right)
           joincon = join_predicate(left, right, on)
-          join = if joincon.tautology?
+          join = if left_join?
+            [:left_join, left.table_spec, right.table_spec, joincon]
+          elsif joincon.tautology?
             [:cross_join, left.table_spec, right.table_spec]
           else
             [:inner_join, left.table_spec, right.table_spec, joincon]
@@ -75,6 +83,26 @@ module Bmg
           order_by.first + order_by.last.sexpr_body
         end
 
+      private
+
+        def left_join?
+          options[:kind] == :left
+        end
+
+        def coalesced(child)
+          drt, as_name = options[:default_right_tuple], child.as_name.to_sym
+          if drt && drt.has_key?(as_name)
+            child.with_update(1, [
+              :func_call,
+              :coalesce,
+              child.left,
+              [:literal, drt[as_name]]
+            ])
+          else
+            child
+          end
+        end
+
       end # class Join
     end # class Processor
   end # module Sql

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

@@ -9,7 +9,7 @@ module Bmg
             h[k.to_s] = builder.next_qualifier!
           }
         end
-        attr_reader :requalify 
+        attr_reader :requalify
 
         alias :on_select_exp :copy_and_apply
         alias :on_missing :copy_and_apply

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
@@ -39,8 +39,8 @@ module Bmg
         def falsy?(sexpr)
           return false unless sexpr.respond_to?(:predicate)
           return false if sexpr.predicate.nil?
-          left  = Predicate.new(Predicate::Grammar.sexpr(sexpr.predicate))
-          right = Predicate.new(Predicate::Grammar.sexpr(@predicate.sexpr))
+          left  = Predicate.new(Predicate::Grammar.sexpr(sexpr.predicate)).unqualify
+          right = Predicate.new(Predicate::Grammar.sexpr(@predicate.sexpr)).unqualify
           return (left & right).contradiction?
         end
 

data/lib/bmg/sql/relation.rb

@@ -18,6 +18,12 @@ module Bmg
 
     public
 
+      def bind(binding)
+        expr = before_use(self.expr)
+        expr = Processor::Bind.new(binding, builder).call(expr)
+        _instance(type, builder, expr)
+      end
+
       def each(&bl)
         raise NotImplementedError
       end
@@ -56,7 +62,21 @@ module Bmg
         if right_expr = extract_compatible_sexpr(right)
           right_expr = Processor::Requalify.new(builder).call(right_expr)
           expr = before_use(self.expr)
-          expr = Processor::Join.new(right_expr, on, builder).call(expr)
+          expr = Processor::Join.new(right_expr, on, {}, builder).call(expr)
+          _instance(type, builder, expr)
+        else
+          super
+        end
+      end
+
+      def _left_join(type, right, on, default_right_tuple)
+        if right_expr = extract_compatible_sexpr(right)
+          right_expr = Processor::Requalify.new(builder).call(right_expr)
+          expr = before_use(self.expr)
+          expr = Processor::Join.new(right_expr, on, {
+            kind: :left,
+            default_right_tuple: default_right_tuple
+          }, builder).call(expr)
           _instance(type, builder, expr)
         else
           super

data/lib/bmg/sql/support/from_clause_orderer.rb

@@ -23,14 +23,14 @@ module Bmg
         # Generates a relationally equivalent list of (type,table,predicate)
         # triplets, where:
         #
-        # - type is :base, :cross_join or :inner_join
+        # - type is :base, :cross_join, :inner_join, or :left_join
         # - table is table_as, native_table_as or subquery_as
         # - predicate is a join predicate `ti.attri = tj.attrj AND ...`
         #
         # So that
         #
         # 1) the types are observed in strict increasing order (one :base, zero
-        #    or more :cross_join, zero or more :inner_join)
+        #    or more :cross_join, zero or more :inner_join, zero or more :left_join)
         #
         # 2) the list is such that it can be safely written as an expression
         #    of the following SQL syntax:
@@ -40,6 +40,7 @@ module Bmg
         #       cross_join t3                 # [ :cross_join, t3, nil ]
         #       inner_join t4 ON p4           # [ :inner_join, t4, p4 ]
         #       inner_join t5 ON p5           # [ :inner_join, t5, p5 ]
+        #       left_join t6 ON p6            # [ :left_join, t6, p6 ]
         #
         #   that is, the linearization is correct only if each predicate `pi`
         #   only makes reference to tables introduced before it (no forward
@@ -87,13 +88,18 @@ module Bmg
         #    reference to tables not introduced yet)
         #
         def order_all(tables, joins)
-          # Our first strategy is simple: let sort the tables by moving the ones
-          # not referenced in join clauses at the beginning of the list => they
-          # will yield the base an cross join clauses first.
-          tables = tables.sort{|t1,t2|
-            t1js = joins.select{|j| uses?(j, t1) }.size
-            t2js = joins.select{|j| uses?(j, t2) }.size
-            t1js == 0 ? (t2js == 0 ? 0 : -1) : (t2js == 0 ? 1 : 0)
+          # Our first strategy is simple: let sort the tables by moving the
+          # all left joins at the end, and all not referenced in join clauses
+          # at the beginning of the list => they will yield the base an cross
+          # join clauses first.
+          tables = tables.sort{|(t1,k1),(t2,k2)|
+            if k1 == :left_join || k2 == :left_join
+              k1 == k2 ? 0 : (k1 == :left_join ? 1 : -1)
+            else
+              t1js = joins.select{|j| uses?(j, t1) }.size
+              t2js = joins.select{|j| uses?(j, t2) }.size
+              t1js == 0 ? (t2js == 0 ? 0 : -1) : (t2js == 0 ? 1 : 0)
+            end
           }
 
           # Then order all recursively in that order of tables, filling a result
@@ -119,7 +125,15 @@ module Bmg
 
             # Decide which kind of join it is, according to the result and
             # the number of join clauses that will be used
-            join_kind = result.empty? ? :base : (on.empty? ? :cross_join : :inner_join)
+            join_kind = if result.empty?
+              :base
+            elsif table.last == :left_join
+              :left_join
+            elsif on.empty?
+              :cross_join
+            else
+              :inner_join
+            end
 
             # Compute the AND([eq]) predicate on selected join clauses
             predicate = on.inject(nil){|p,clause|
@@ -127,7 +141,7 @@ module Bmg
             }
 
             # Recurse with that new clause in the result
-            clause = [ join_kind, table, predicate ]
+            clause = [ join_kind, table[0], predicate ]
             _order_all(tables_tail, joins_tail, result + [clause])
           end
         end
@@ -139,13 +153,13 @@ module Bmg
         # `ti` and making no reference to non introduced tables, and the others.
         def split_joins(joins, table, tables_tail)
           joins.partition{|j|
-            uses?(j, table) && !tables_tail.find{|t|
-              uses?(j, t)
+            uses?(j, table[0]) && !tables_tail.find{|t|
+              uses?(j, t[0])
             }
           }
         end
 
-        # Returns whether the join
+        # Returns whether the join conditions references the given table
         def uses?(condition, table)
           name = table.as_name.to_s
           left_name = var_name(condition[1])
@@ -172,23 +186,27 @@ module Bmg
         def collect(sexpr)
           tables = []
           joins  = []
-          _collect(sexpr, tables, joins)
+          _collect(sexpr, tables, joins, :base)
           [ tables, joins ]
         end
 
-        def _collect(sexpr, tables, joins)
+        def _collect(sexpr, tables, joins, kind)
           case sexpr.first
           when :from_clause
-            _collect(sexpr.table_spec, tables, joins)
+            _collect(sexpr.table_spec, tables, joins, kind)
           when :table_as, :native_table_as, :subquery_as
-            tables << sexpr
+            tables << [sexpr, kind]
+          when :cross_join
+            _collect(sexpr.left, tables, joins, :cross_join)
+            _collect(sexpr.right, tables, joins, :cross_join)
           when :inner_join
             _collect_joins(sexpr.predicate, joins)
-            _collect(sexpr.left, tables, joins)
-            _collect(sexpr.right, tables, joins)
-          when :cross_join
-            _collect(sexpr.left, tables, joins)
-            _collect(sexpr.right, tables, joins)
+            _collect(sexpr.left, tables, joins, :inner_join)
+            _collect(sexpr.right, tables, joins, :inner_join)
+          when :left_join
+            _collect_joins(sexpr.predicate, joins)
+            _collect(sexpr.left, tables, joins, kind)
+            _collect(sexpr.right, tables, joins, :left_join)
           end
         end
 

data/lib/bmg/type.rb

@@ -175,6 +175,15 @@ module Bmg
       }
     end
 
+    def left_join(right, on, default_right_tuple)
+      join_compatible!(right, on) if typechecked? && knows_attrlist?
+      dup.tap{|x|
+        x.attrlist  = (knows_attrlist? and right.knows_attrlist?) ? (self.attrlist + right.attrlist).uniq : nil
+        x.predicate = Predicate.tautology
+        x.keys      = nil
+      }
+    end
+
     def matching(right, on)
       join_compatible!(right, on) if typechecked? && knows_attrlist?
       self

data/lib/bmg/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.16.7
+  version: 0.17.4
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-15 00:00:00.000000000 Z
+date: 2020-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '2.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.1
+        version: 2.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '2.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.1
+        version: 2.4.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -194,9 +194,12 @@ files:
 - lib/bmg/sql/nodes/except.rb
 - lib/bmg/sql/nodes/expr.rb
 - lib/bmg/sql/nodes/from_clause.rb
+- lib/bmg/sql/nodes/func_call.rb
 - lib/bmg/sql/nodes/group_by_clause.rb
 - lib/bmg/sql/nodes/inner_join.rb
 - lib/bmg/sql/nodes/intersect.rb
+- lib/bmg/sql/nodes/join.rb
+- lib/bmg/sql/nodes/left_join.rb
 - lib/bmg/sql/nodes/limit_clause.rb
 - lib/bmg/sql/nodes/literal.rb
 - lib/bmg/sql/nodes/name_intro.rb
@@ -222,6 +225,7 @@ files:
 - lib/bmg/sql/nodes/with_spec.rb
 - lib/bmg/sql/processor.rb
 - lib/bmg/sql/processor/all.rb
+- lib/bmg/sql/processor/bind.rb
 - lib/bmg/sql/processor/clip.rb
 - lib/bmg/sql/processor/constants.rb
 - lib/bmg/sql/processor/distinct.rb