bmg 0.17.1 → 0.17.6

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/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/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

@@ -62,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