bmg 0.9.1 → 0.10.0

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

@@ -0,0 +1,17 @@
+module Bmg
+  module Sql
+    class Processor
+      class Distinct < Processor
+
+        def on_set_quantified(sexpr)
+          sexpr.with_update(1, builder.distinct)
+        end
+        alias :on_union      :on_set_quantified
+        alias :on_except     :on_set_quantified
+        alias :on_intersect  :on_set_quantified
+        alias :on_select_exp :on_set_quantified
+
+      end # class Distinct
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,24 @@
+module Bmg
+  module Sql
+    class Processor
+      class Flatten < Processor
+
+        def on_with_exp(sexpr)
+          @subqueries = sexpr.with_spec.to_hash
+          apply(sexpr.select_exp)
+        end
+        attr_reader :subqueries
+
+        alias :on_select_exp :copy_and_apply
+        alias :on_missing    :copy_and_apply
+
+        def on_table_as(sexpr)
+          return sexpr unless subqueries
+          return sexpr unless subquery = subqueries[sexpr.table_name]
+          [ :subquery_as, apply(subquery), sexpr.right ]
+        end
+
+      end # class Flatten
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,29 @@
+module Bmg
+  module Sql
+    class Processor
+      class FromSelf < Processor
+
+        def on_with_exp(sexpr)
+          q = builder.next_qualifier!
+          name_intro = builder.name_intro(q, sexpr.select_exp)
+          [ :with_exp,
+            sexpr.with_spec.dup.push(name_intro),
+            builder.select_all(sexpr.select_exp, q, q) ]
+        end
+
+        def on_nonjoin_exp(sexpr)
+          q = builder.next_qualifier!
+          [ :with_exp,
+            [:with_spec,
+              builder.name_intro(q, sexpr)],
+            builder.select_all(sexpr, q, q) ]
+        end
+        alias :on_union      :on_nonjoin_exp
+        alias :on_except     :on_nonjoin_exp
+        alias :on_intersect  :on_nonjoin_exp
+        alias :on_select_exp :on_nonjoin_exp
+
+      end # class FromSelf
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,80 @@
+module Bmg
+  module Sql
+    class Processor
+      class Join < Processor
+        include JoinSupport
+
+        def initialize(right, builder)
+          super(builder)
+          @right = right
+        end
+        attr_reader :right
+
+        def call(sexpr)
+          if unjoinable?(sexpr)
+            call(builder.from_self(sexpr))
+          elsif unjoinable?(right)
+            Join.new(builder.from_self(right), builder).call(sexpr)
+          else
+            super(sexpr)
+          end
+        end
+
+      private
+
+        def apply_join_strategy(left, right)
+          [ :select_exp,
+            join_set_quantifiers(left, right),
+            join_select_lists(left, right),
+            join_from_clauses(left, right),
+            join_where_clauses(left, right),
+            join_order_by_clauses(left, right) ].compact
+        end
+
+        def unjoinable?(sexpr)
+          sexpr.set_operator? or sexpr.limit_or_offset? or sexpr.join?
+        end
+
+        def join_set_quantifiers(left, right)
+          left_q, right_q = left.set_quantifier, right.set_quantifier
+          left_q == right_q ? left_q : builder.distinct
+        end
+
+        def join_select_lists(left, right)
+          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)
+          end
+          list
+        end
+
+        def join_from_clauses(left, right)
+          joincon = join_predicate(left, right)
+          join = if joincon.tautology?
+            [:cross_join, left.table_spec, right.table_spec]
+          else
+            [:inner_join, left.table_spec, right.table_spec, joincon]
+          end
+          left.from_clause.with_update(-1, join)
+        end
+
+        def join_where_clauses(left, right)
+          predicate = [ tautology, left.predicate, right.predicate ].compact
+          case predicate.size
+          when 1 then nil
+          when 2 then [ :where_clause, predicate.last ]
+          else [ :where_clause, predicate.reduce(:&) ]
+          end
+        end
+
+        def join_order_by_clauses(left, right)
+          order_by = [ left.order_by_clause, right.order_by_clause ].compact
+          return order_by.first if order_by.size <= 1
+          order_by.first + order_by.last.sexpr_body
+        end
+
+      end # class Join
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,28 @@
+module Bmg
+  module Sql
+    class Processor
+      module JoinSupport
+
+        def on_main_exp(sexpr)
+          joined = apply_join_strategy(sexpr.select_exp, right.select_exp)
+          merge_with_exps(sexpr, right, joined)
+        end
+        alias :on_with_exp   :on_main_exp
+        alias :on_select_exp :on_main_exp
+
+      private
+
+        def join_predicate(left, right, commons)
+          left_d, right_d = left.desaliaser, right.desaliaser
+          commons.to_a.inject(tautology){|cond, attr|
+            left_attr, right_attr = left_d[attr], right_d[attr]
+            left_p  = Predicate::Factory.qualified_identifier(left_attr.qualifier, left_attr.as_name)
+            right_p = Predicate::Factory.qualified_identifier(right_attr.qualifier, right_attr.as_name)
+            cond &= Predicate::Factory.eq(left_p, right_p)
+          }
+        end
+
+      end # class JoinSupport
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,30 @@
+module Bmg
+  module Sql
+    class Processor
+      class LimitOffset < Processor
+
+        def initialize(limit, offset, builder)
+          super(builder)
+          @limit = limit
+          @offset = offset
+        end
+        attr_reader :limit, :offset
+
+        def on_set_operator(sexpr)
+          apply(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)
+          sexpr  = builder.from_self(sexpr) if obc = sexpr.limit_or_offset?
+          limit_clause = builder.limit_clause(limit)
+          offset_clause = builder.offset_clause(offset)
+          sexpr.with_push(limit_clause, offset_clause)
+        end
+
+      end # class LimitOffset
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,49 @@
+module Bmg
+  module Sql
+    class Processor
+      class Merge < Processor
+
+        def initialize(kind, all, right, builder)
+          super(builder)
+          @kind = kind
+          @all = all
+          @right = right
+        end
+
+        def on_with_exp(sexpr)
+          if @right.with_exp?
+            reordered = Reorder.new(sexpr.to_attr_list, builder).call(@right)
+            main = [ @kind, modifier, sexpr.select_exp, reordered.select_exp ]
+            merge_with_exps(sexpr, reordered, main)
+          else
+            [ :with_exp,
+              sexpr.with_spec,
+              apply(sexpr.last) ]
+          end
+        end
+
+        def on_nonjoin_exp(sexpr)
+          reordered = Reorder.new(sexpr.to_attr_list, builder).call(@right)
+          if @right.with_exp?
+            [ :with_exp,
+              reordered.with_spec,
+              [ @kind, modifier, sexpr, reordered.select_exp ] ]
+          else
+            [ @kind, modifier, sexpr, reordered ]
+          end
+        end
+        alias :on_union      :on_nonjoin_exp
+        alias :on_except     :on_nonjoin_exp
+        alias :on_intersect  :on_nonjoin_exp
+        alias :on_select_exp :on_nonjoin_exp
+
+      private
+
+        def modifier
+          @all ? builder.all : builder.distinct
+        end
+
+      end # class Merge
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,32 @@
+module Bmg
+  module Sql
+    class Processor
+      class OrderBy < Processor
+
+        def initialize(ordering, builder)
+          super(builder)
+          @ordering = ordering
+        end
+        attr_reader :ordering
+
+        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.order_by_clause
+            sexpr = builder.from_self(sexpr)
+            call(sexpr)
+          else
+            needed = builder.order_by_clause(ordering, &sexpr.desaliaser)
+            sexpr.dup.push(needed)
+          end
+        end
+
+      end # class OrderBy
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,25 @@
+module Bmg
+  module Sql
+    class Processor
+      class Rename < Processor
+
+        def initialize(renaming, builder)
+          super(builder)
+          @renaming = renaming
+        end
+
+        def on_select_list(sexpr)
+          sexpr.each_with_index.map{|child,index|
+            index == 0 ? child : apply(child)
+          }
+        end
+
+        def on_select_item(sexpr)
+          return sexpr unless newname = @renaming[sexpr.as_name.to_sym]
+          builder.select_item(sexpr.qualifier, sexpr.would_be_name, newname.to_s)
+        end
+
+      end # class Rename
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,21 @@
+module Bmg
+  module Sql
+    class Processor
+      class Reorder < Processor
+
+        def initialize(attr_list, builder)
+          super(builder)
+          @indexes = Hash[attr_list.to_a.map(&:to_s).each_with_index.to_a]
+        end
+
+        def on_select_list(sexpr)
+          reordered = sexpr.sexpr_body.sort{|i1,i2|
+            @indexes[i1.as_name] <=> @indexes[i2.as_name]
+          }
+          reordered.unshift(:select_list)
+        end
+
+      end # class Reorder
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,24 @@
+module Bmg
+  module Sql
+    class Processor
+      class Requalify < Processor
+
+        def initialize(builder)
+          super
+          @requalify = Hash.new{|h,k|
+            h[k] = Grammar.sexpr [:range_var_name, builder.next_qualifier!]
+          }
+        end
+        attr_reader :requalify 
+
+        alias :on_select_exp :copy_and_apply
+        alias :on_missing :copy_and_apply
+
+        def on_range_var_name(sexpr)
+          requalify[sexpr]
+        end
+
+      end # class Requalify
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,68 @@
+module Bmg
+  module Sql
+    class Processor
+      class SemiJoin < Processor
+        include JoinSupport
+
+        def initialize(right, on, negate = false, builder)
+          super(builder)
+          @right  = right
+          @on = on
+          @negate = negate
+        end
+        attr_reader :right, :on, :negate
+
+        def call(sexpr)
+          if sexpr.set_operator?
+            call(builder.from_self(sexpr))
+          elsif right.set_operator?
+            SemiJoin.new(builder.from_self(right), negate, builder).call(sexpr)
+          else
+            super(sexpr)
+          end
+        end
+
+      private
+
+        def apply_join_strategy(left, right)
+          predicate = build_semijoin_predicate(left, right)
+          expand_where_clause(left, negate ? !predicate : predicate)
+        end
+
+        def build_semijoin_predicate(left, right)
+          if right.is_table_dee?
+            right.where_clause.predicate
+          else
+            commons = self.on
+            subquery = Clip.new(commons, false, :star, builder).call(right)
+            subquery = Requalify.new(builder).call(subquery)
+            if commons.size == 0
+              builder.exists(subquery)
+            elsif commons.size == 1
+              identifier = left.desaliaser[commons.to_a.first]
+              Predicate::Factory.in(identifier, subquery)
+            else
+              join_pre  = join_predicate(left, subquery, commons)
+              subquery  = expand_where_clause(subquery, join_pre)
+              subquery  = Star.new(builder).call(subquery)
+              builder.exists(subquery)
+            end
+          end
+        end
+
+        def expand_where_clause(sexpr, predicate)
+          Grammar.sexpr \
+            [ :select_exp,
+              sexpr.set_quantifier,
+              sexpr.select_list,
+              sexpr.from_clause,
+              [ :where_clause, (sexpr.predicate || tautology) & predicate ],
+              sexpr.order_by_clause,
+              sexpr.limit_clause,
+              sexpr.offset_clause ].compact
+        end
+
+      end # class SemiJoin
+    end # class Processor
+  end # module Sql
+end # module Bmg

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

@@ -0,0 +1,17 @@
+module Bmg
+  module Sql
+    class Processor
+      class Star < Processor
+
+        def on_select_exp(sexpr)
+          if sexpr.from_clause
+            sexpr.with_update(:select_list, builder.select_star)
+          else
+            sexpr
+          end
+        end
+
+      end # class Star
+    end # class Processor
+  end # module Sql
+end # module Bmg