bmg 0.16.0.pre.rc1 → 0.16.0.pre.rc2

data/lib/bmg/sequel/translator.rb

@@ -42,6 +42,7 @@ module Bmg
         #
         selection = apply(sexpr.select_list)
         predicate = apply(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
         offset    = apply(sexpr.offset_clause)   if sexpr.offset_clause
@@ -49,6 +50,7 @@ module Bmg
         dataset   = dataset.select(*selection)
         dataset   = dataset.distinct             if sexpr.distinct?
         dataset   = dataset.where(predicate)     if predicate
+        dataset   = dataset.group(grouping)      if grouping
         dataset   = dataset.order_by(*order)     if order
         dataset   = dataset.limit(limit, offset == 0 ? nil : offset) if limit or offset
         dataset
@@ -68,13 +70,21 @@ module Bmg
         case kind = sexpr.left.first
         when :qualified_name
           left.column == right.value ? left : ::Sequel.as(left, right)
-        when :literal
+        when :literal, :summarizer
           ::Sequel.as(left, right)
         else
           raise NotImplementedError, "Unexpected select item `#{kind}`"
         end
       end
 
+      def on_summarizer(sexpr)
+        if sexpr.summary_expr
+          ::Sequel.function(sexpr.summary_func, apply(sexpr.summary_expr))
+        else
+          ::Sequel.function(sexpr.summary_func).*
+        end
+      end
+
       def on_qualified_name(sexpr)
         apply(sexpr.last).qualify(sexpr.qualifier)
       end
@@ -116,6 +126,11 @@ module Bmg
         ::Sequel.as(apply(sexpr.subquery), ::Sequel.identifier(sexpr.as_name))
       end
 
+      def on_group_by_clause(sexpr)
+        return nil unless sexpr.size > 1
+        sexpr.sexpr_body.map{|c| apply(c)}
+      end
+
       def on_order_by_clause(sexpr)
         sexpr.sexpr_body.map{|c| apply(c)}
       end

data/lib/bmg/sql/builder.rb

@@ -146,6 +146,14 @@ module Bmg
         Predicate::Grammar.sexpr [ :exists, subquery ]
       end
 
+      def group_by_clause(attrlist, &desaliaser)
+        attrlist.map{|name|
+          name = name.to_s
+          (desaliaser && desaliaser[name]) || column_name(name)
+        }.unshift(:group_by_clause)
+      end
+      builder :group_by_clause
+
       def order_by_clause(ordering, &desaliaser)
         ordering.to_a.map{|(name,direction)|
           name = name.to_s

data/lib/bmg/sql/grammar.rb

@@ -30,6 +30,7 @@ require_relative "nodes/table_as"
 require_relative "nodes/native_table_as"
 require_relative "nodes/subquery_as"
 require_relative "nodes/table_name"
+require_relative "nodes/group_by_clause"
 require_relative "nodes/order_by_clause"
 require_relative "nodes/order_by_term"
 require_relative "nodes/limit_clause"
@@ -43,3 +44,4 @@ require_relative "nodes/name_intro"
 require_relative "nodes/where_clause"
 require_relative "nodes/cross_join"
 require_relative "nodes/inner_join"
+require_relative "nodes/summarizer"

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

@@ -35,6 +35,7 @@ rules:
         [ select_list, select_star ],
         from_clause,
         where_clause,
+        group_by_clause,
         order_by_clause,
         limit_clause,
         offset_clause ]
@@ -50,6 +51,8 @@ rules:
     - [ table_spec ]
   where_clause:
     - [ predicate ]
+  group_by_clause:
+    - [ a_name ]
   order_by_clause:
     - [ order_by_term+ ]
   order_by_term:
@@ -72,11 +75,19 @@ rules:
   scalar_exp:
     - qualified_name
     - column_name
+    - summarizer
     - literal
+  a_name:
+    - qualified_name
+    - column_name
   qualified_name:
     - [ range_var_name, column_name ]
   column_name:
     - [ name_rgx ]
+  summarizer:
+    - [ summary_func, qualified_name ]
+  summary_func:
+    - "::Symbol"
   table_name:
     - [ name_rgx ]
   range_var_name:

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

@@ -0,0 +1,20 @@
+module Bmg
+  module Sql
+    module GroupByClause
+      include Expr
+
+      GROUP_BY = "GROUP BY".freeze
+
+      def to_sql(buffer, dialect)
+        return buffer if size == 1
+        buffer << GROUP_BY << SPACE
+        each_child do |item,index|
+          buffer << COMMA << SPACE unless index == 0
+          item.to_sql(buffer, dialect)
+        end
+        buffer
+      end
+
+    end # module GroupByClause
+  end # module Sql
+end # module Bmg

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

@@ -67,6 +67,10 @@ module Bmg
         from_clause.table_spec
       end
 
+      def group_by_clause
+        find_child(:group_by_clause)
+      end
+
       def order_by_clause
         find_child(:order_by_clause)
       end

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

@@ -0,0 +1,23 @@
+module Bmg
+  module Sql
+    module Summarizer
+      include Expr
+
+      def summary_func
+        self[1]
+      end
+
+      def summary_expr
+        self.last
+      end
+
+      def to_sql(buffer, dialect)
+        buffer << summary_func.upcase << "("
+        summary_expr.to_sql(buffer, dialect)
+        buffer << ")"
+        buffer
+      end
+
+    end # module Summarizer
+  end # module Sql
+end # module Bmg

data/lib/bmg/sql/processor.rb

@@ -84,3 +84,4 @@ require_relative 'processor/join'
 require_relative 'processor/semi_join'
 require_relative 'processor/flatten'
 require_relative 'processor/requalify'
+require_relative 'processor/summarize'

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

@@ -0,0 +1,48 @@
+module Bmg
+  module Sql
+    class Processor
+      class Summarize < Processor
+
+        def initialize(by, summarization, builder)
+          super(builder)
+          @by = by
+          @summarization = summarization
+        end
+        attr_reader :by, :summarization
+
+        def on_set_operator(sexpr)
+          call(builder.from_self(sexpr))
+        end
+        alias :on_union     :on_set_operator
+        alias :on_except    :on_set_operator
+        alias :on_intersect :on_set_operator
+
+        def on_select_exp(sexpr)
+          if obc = sexpr.group_by_clause
+            sexpr = builder.from_self(sexpr)
+            call(sexpr)
+          else
+            sexpr = sexpr.with_update(:select_list, apply(sexpr.select_list))
+            group_by = builder.group_by_clause(by, &sexpr.desaliaser)
+            sexpr.push(group_by)
+          end
+        end
+
+        def on_select_list(sexpr)
+          by_list = sexpr.sexpr_body.select{|select_item|
+            by.include?(select_item.last.last.to_sym)
+          }
+          group_list = summarization.map{|attr,summarizer|
+            [:select_item,
+              [ :summarizer,
+                summarizer.to_summarizer_name,
+                sexpr.desaliaser[attr] ],
+              [:column_name, attr.to_s] ]
+          }
+          [:select_list] + by_list + group_list
+        end
+
+      end # class Summarize
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -20,12 +20,17 @@ module Bmg
         end
 
         def on_select_exp(sexpr)
-          pred = @predicate.rename(sexpr.desaliaser(true))
-          if sexpr.where_clause
-            sexpr_p = Predicate.new(sexpr.where_clause.predicate)
-            sexpr.with_update(:where_clause, [ :where_clause, (sexpr_p & pred).sexpr ])
+          if sexpr.group_by_clause
+            sexpr = builder.from_self(sexpr)
+            call(sexpr)
           else
-            sexpr.with_insert(4, [ :where_clause, pred.sexpr ])
+            pred = @predicate.rename(sexpr.desaliaser(true))
+            if sexpr.where_clause
+              sexpr_p = Predicate.new(sexpr.where_clause.predicate)
+              sexpr.with_update(:where_clause, [ :where_clause, (sexpr_p & pred).sexpr ])
+            else
+              sexpr.with_insert(4, [ :where_clause, pred.sexpr ])
+            end
           end
         end
 

data/lib/bmg/sql/relation.rb

@@ -114,6 +114,23 @@ module Bmg
         _instance(type, builder, expr)
       end
 
+      def _summarize(type, by, summarization)
+        summarization = Operator::Summarize.compile(summarization)
+        if can_compile_summarization?(summarization)
+          expr = before_use(self.expr)
+          expr = Processor::Summarize.new(by, summarization, builder).call(self.expr)
+          _instance(type, builder, expr)
+        else
+          super
+        end
+      end
+
+      def can_compile_summarization?(summarization)
+        summarization.values.all?{|s|
+          [:avg, :count, :max, :min, :sum].include?(s.to_summarizer_name)
+        }
+      end
+
       def _union(type, right, options)
         if right_expr = extract_compatible_sexpr(right)
           expr = before_use(self.expr)

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

@@ -3,51 +3,140 @@ module Bmg
     module Support
       class FromClauseOrderer
 
-        # Takes a from_clause AST as input and generates an relationally
-        # equivalent list of (type,table,predicate) triplets, where:
+        # Given a `from_clause` AST as input, e.g.
+        #
+        #     [ :from_clause,
+        #       [ :cross_join
+        #         [ :inner_join,
+        #           [ :inner_join,
+        #             [ :table_as, "suppliers", "s"  ],
+        #             [ :table_as, "supplies",  "sp" ],
+        #             [ :eq, [ :qualified, "s", "sid" ], [ :qualified, "sp", "sid" ] ]
+        #           ],
+        #           [ :table_as, "parts", "p" ],
+        #           [ :eq, [ :qualified, "p", "pid" ], [ :qualified "sp", "pid" ] ]
+        #         ],
+        #         [ :table_as, "cities", "c" ],
+        #       ]
+        #     ]
+        #
+        # Generates a relationally equivalent list of (type,table,predicate)
+        # triplets, where:
         #
         # - type is :base, :cross_join or :inner_join
         # - table is table_as, native_table_as or subquery_as
-        # - predicate is a join predicate
+        # - 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)
+        #
+        # 2) the list is such that it can be safely written as an expression
+        #    of the following SQL syntax:
+        #
+        #       t1                            # [ :base, t1, nil ]
+        #       cross_join t2                 # [ :cross_join, t2, nil ]
+        #       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 ]
+        #
+        #   that is, the linearization is correct only if each predicate `pi`
+        #   only makes reference to tables introduced before it (no forward
+        #   reference).
         #
-        # The types are observed in strict increasing order
-        # (one :base, zero or more :cross_join, zero or more
-        # :inner_join). The list is such that it can be safely
-        # written as an expression of the following SQL form:
+        # For the example above, a solution might be:
         #
-        #     t1                            # [ :base, t1, nil ]
-        #     cross_join t2                 # [ :cross_join, t2, nil ]
-        #     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 ]
+        #     [
+        #       [ :base,       [ :table_as, "suppliers", "s"  ], nil ],
+        #       [ :cross_join, [ :table_as, "cities", "c" ],     nil ],
+        #       [ :inner_join, [ :table_as, "supplies",  "sp" ],
+        #           [ :eq, [ :qualified, "s", "sid" ], [ :qualified, "sp", "sid" ] ] ],
+        #       [ :inner_join, [ :table_as, "parts", "p" ],
+        #           [ :eq, [ :qualified, "p", "pid" ], [ :qualified "sp", "pid" ] ] ]
+        #     ]
         #
-        # A NotImplementedError may be raised if no linearization can
-        # be found.
+        # A NotImplementedError may be raised if no linearization can be found.
         #
         def call(sexpr)
+          # The algorithm works in two phases: we first collect all table
+          # references and JOIN clauses by simple inspection of the AST.
           tables, joins = collect(sexpr)
+
+          # Then we order the tables and join clauses so as to find the
+          # linearization.
           order_all(tables, joins)
         end
 
-      protected
+      protected  ## Second phase: linearization per se
 
-        def order_all(tables, joins, result = [])
+        # Given a non empty list of tables `ti` and a possibly empty list of
+        # join conditions `ti.attri = tj.attrj`, returns a linearization of
+        # join triplets meeting the following POST conditions:
+        #
+        # 1. A triplet is either `[ :base, ti, nil ]`, `[:cross_join, ti, nil]`
+        #    or `[ :inner_join, ti, AND([eq]) ]` where `eq` is of the form
+        #   `ti.attri = tj.attrj`
+        #
+        # 2. one and only on `:base` triplet comes first, then `:cross_join`
+        #    ones, then `:inner_join` ones.
+        #
+        # 3. an inner clause at position x in the resulting list is such that
+        #    its join conditions `eq` only make reference to tables `ti` that
+        #    have been introduced before or in x itself (i.e. no forward
+        #    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)
+          }
+
+          # Then order all recursively in that order of tables, filling a result
+          # array that will be returned
+          _order_all(tables, joins, [])
+        end
+
+        def _order_all(tables, joins, result)
           if tables.empty? and joins.empty?
+            # end or recusion
             result
           elsif tables.empty?
+            # Why will this never happen exactly??
             raise NotImplementedError, "Orphan joins: `#{joins.inspect}`"
           else
+            # Greedy strategy: we take the first table in the list and keep the
+            # rest for recursion later
             table, tables_tail = tables.first, tables[1..-1]
+
+            # Split the remaining joins in two lists: those referencing only
+            # introduced tables, and those making forward references
             on, joins_tail = split_joins(joins, table, tables_tail)
+
+            # 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)
+
+            # Compute the AND([eq]) predicate on selected join clauses
             predicate = on.inject(nil){|p,clause|
               p.nil? ? clause : Predicate::Factory.and(p, clause)
             }
+
+            # Recurse with that new clause in the result
             clause = [ join_kind, table, predicate ]
-            order_all(tables_tail, joins_tail, result + [clause])
+            _order_all(tables_tail, joins_tail, result + [clause])
           end
         end
 
+        # Given a list of join `ti.attri = tj.attrj` clauses, a newly introduced
+        # ti `table`, and a set of non-yet-introduced tables `tables_tail`,...
+        #
+        # ... split the joins in two sublists: those making references to table
+        # `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|
@@ -56,17 +145,34 @@ module Bmg
           }
         end
 
-      protected
+        # Returns whether the join
+        def uses?(condition, table)
+          name = table.as_name.to_s
+          left_name = var_name(condition[1])
+          right_name = var_name(condition[2])
+          (left_name == name) or (right_name == name)
+        end
+
+        # Given a `ti.attri` expression (AST node), returns `ti`
+        def var_name(qualified)
+          case qualified.first
+          when :qualified_identifier then qualified[1].to_s
+          when :qualified_name       then qualified[1][1].to_s
+          else
+            raise NotImplementedError, "Unexpected qualified name `#{qualified.inspect}`"
+          end
+        end
+
+      protected ## First phase: collection of tables and join clauses
 
+        # Given a `from_clause` AST (see grammar.sexp.yml), returns two
+        # lists:
+        # - one with tables `ti` (`table_as`, `native_table_as` & `subquery_as`)
+        # - another one with all equality conditions of the form `ti.attri = tj.attrj`
         def collect(sexpr)
           tables = []
           joins  = []
           _collect(sexpr, tables, joins)
-          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)
-          }
           [ tables, joins ]
         end
 
@@ -98,22 +204,6 @@ module Bmg
           end
         end
 
-        def uses?(join, table)
-          name = table.as_name.to_s
-          left_name = var_name(join[1])
-          right_name = var_name(join[2])
-          (left_name == name) or (right_name == name)
-        end
-
-        def var_name(qualified)
-          case qualified.first
-          when :qualified_identifier then qualified[1].to_s
-          when :qualified_name       then qualified[1][1].to_s
-          else
-            raise NotImplementedError, "Unexpected qualified name `#{qualified.inspect}`"
-          end
-        end
-
       end # class FromClauseOrderer
     end # module Support
   end # module Sql