alf-sql 0.15.0

data/lib/alf/sql/nodes/where_clause.rb

@@ -0,0 +1,20 @@
+module Alf
+  module Sql
+    module WhereClause
+      include Expr
+
+      WHERE = "WHERE".freeze
+
+      def predicate
+        last
+      end
+
+      def to_sql(buffer = "")
+        buffer << WHERE << SPACE
+        predicate.to_sql(buffer)
+        buffer
+      end
+
+    end # module WhereClause
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/with_exp.rb

@@ -0,0 +1,50 @@
+module Alf
+  module Sql
+    module WithExp
+      include Expr
+      extend Forwardable
+
+      WITH = "WITH".freeze
+
+      def with_exp?
+        true
+      end
+
+      def with_spec
+        self[1]
+      end
+
+      def select_exp
+        last
+      end
+      def_delegators :select_exp, :select_list,
+                                  :where_clause,
+                                  :predicate,
+                                  :from_clause,
+                                  :table_spec,
+                                  :order_by_clause,
+                                  :limit_clause,
+                                  :offset_clause,
+                                  :desaliaser,
+                                  :to_attr_list,
+                                  :to_ordering,
+                                  :all?,
+                                  :distinct?,
+                                  :set_operator?,
+                                  :limit_or_offset?,
+                                  :join?,
+                                  :should_be_reused?
+
+    # to_xxx
+
+      def to_sql(buffer = "")
+        buffer << WITH << SPACE
+        self[1].to_sql(buffer)
+        buffer << SPACE
+        self[2].to_sql(buffer, false)
+        buffer
+      end
+
+    end # module WithExp
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/with_spec.rb

@@ -0,0 +1,24 @@
+module Alf
+  module Sql
+    module WithSpec
+      include Expr
+
+      def to_sql(buffer = "")
+        each_child do |child,index|
+          buffer << COMMA << SPACE unless index==0
+          child.to_sql(buffer)
+        end
+        buffer
+      end
+
+      def to_hash
+        hash = {}
+        each_child do |child|
+          hash[child.table_name.value] = child.subquery
+        end
+        hash
+      end
+
+    end # module WithSpec
+  end # module Sql
+end # module Alf

data/lib/alf/sql/processor.rb

@@ -0,0 +1,85 @@
+module Alf
+  module Sql
+    class Processor < Sexpr::Rewriter
+      grammar Sql::Grammar
+
+      UnexpectedError = Class.new(Alf::Error)
+
+      def initialize(builder)
+        @builder = builder
+      end
+      attr_reader :builder
+
+      def on_with_exp(sexpr)
+        applied = apply(sexpr.select_exp)
+        if applied.with_exp?
+          merge_with_exps(sexpr, applied, applied.select_exp)
+        else
+          sexpr.with_update(-1, applied)
+        end
+      end
+
+      def on_set_operator(sexpr)
+        sexpr.each_with_index.map{|child,index|
+          index <= 1 ? child : apply(child)
+        }
+      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.with_update(2, apply(sexpr[2]))
+      end
+
+    private
+
+      def merge_with_exps(left, right, main)
+        if left.with_exp? and right.with_exp?
+          [ :with_exp,
+            merge_with_specs(left.with_spec, right.with_spec),
+            main ]
+        elsif left.with_exp?
+          left.with_update(-1, main)
+        elsif right.with_exp?
+          right.with_update(-1, main)
+        else
+          main
+        end
+      end
+
+      def merge_with_specs(left, right)
+        hash = left.to_hash.merge(right.to_hash){|k,v1,v2|
+          unless v1 == v2
+            msg = "Unexpected different SQL expr: "
+            msg << "`#{v1.to_sql}` vs. `#{v2.to_sql}`"
+            raise UnexpectedError, msg
+          end
+          v1
+        }
+        hash.map{|(k,v)| builder.name_intro(k,v) }.unshift(:with_spec)
+      end
+
+      def tautology
+        Predicate::Factory.tautology
+      end
+
+    end
+  end
+end
+require_relative 'processor/distinct'
+require_relative 'processor/all'
+require_relative 'processor/clip'
+require_relative 'processor/star'
+require_relative 'processor/rename'
+require_relative 'processor/order_by'
+require_relative 'processor/limit_offset'
+require_relative 'processor/from_self'
+require_relative 'processor/reorder'
+require_relative 'processor/merge'
+require_relative 'processor/where'
+require_relative 'processor/join_support'
+require_relative 'processor/join'
+require_relative 'processor/semi_join'
+require_relative 'processor/flatten'
+require_relative 'processor/requalify'

data/lib/alf/sql/processor/all.rb

@@ -0,0 +1,17 @@
+module Alf
+  module Sql
+    class Processor
+      class All < Processor
+
+        def on_set_quantified(sexpr)
+          sexpr.with_update(1, builder.all)
+        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 All
+    end # class Processor
+  end # module Sql
+end # module Alf

data/lib/alf/sql/processor/clip.rb

@@ -0,0 +1,39 @@
+module Alf
+  module Sql
+    class Processor
+      class Clip < Processor
+
+        def initialize(attributes, on_empty = :is_table_dee, builder)
+          super(builder)
+          @attributes = attributes
+          @on_empty = on_empty
+        end
+        attr_reader :attributes, :on_empty
+
+        def on_select_exp(sexpr)
+          catch(:empty){ return super(sexpr) }
+          send("select_#{on_empty}", sexpr)
+        end
+
+        def on_select_list(sexpr)
+          result = sexpr.select{|child|
+            (child == :select_list) or
+            attributes.include?(child.as_name.to_sym)
+          }
+          (result.size==1) ? throw(:empty) : result
+        end
+
+      private
+
+        def select_is_table_dee(sexpr)
+          builder.select_is_table_dee(select_star(sexpr))
+        end
+
+        def select_star(sexpr)
+          All.new(builder).call(Star.new(builder).call(sexpr))
+        end
+
+      end # class Clip
+    end # class Processor
+  end # module Sql
+end # module Alf

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

@@ -0,0 +1,17 @@
+module Alf
+  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 Alf

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

@@ -0,0 +1,24 @@
+module Alf
+  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 Alf

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

@@ -0,0 +1,29 @@
+module Alf
+  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 Alf

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

@@ -0,0 +1,80 @@
+module Alf
+  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 Alf

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

@@ -0,0 +1,27 @@
+module Alf
+  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.to_attr_list & right.to_attr_list)
+          commons = left.to_attr_list & right.to_attr_list
+          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]
+            cond &= Predicate::Factory.eq(left_attr, right_attr)
+          }
+        end
+
+      end # class JoinSupport
+    end # class Processor
+  end # module Sql
+end # module Alf

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

@@ -0,0 +1,30 @@
+module Alf
+  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 Alf