alf-sql 0.15.0

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

@@ -0,0 +1,42 @@
+module Alf
+  module Sql
+    class Processor
+      class Merge < Processor
+
+        def initialize(kind, right, builder)
+          super(builder)
+          @kind = kind
+          @right = right
+        end
+
+        def on_with_exp(sexpr)
+          if @right.with_exp?
+            reordered = Reorder.new(sexpr.to_attr_list, builder).call(@right)
+            main = [ @kind, builder.distinct, 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, builder.distinct, sexpr, reordered.select_exp ] ]
+          else
+            [ @kind, builder.distinct, 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
+
+      end # class Merge
+    end # class Processor
+  end # module Sql
+end # module Alf

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,57 @@
+module Alf
+  module Sql
+    class Processor
+      class SemiJoin < Processor
+        include JoinSupport
+
+        def initialize(right, negate = false, builder)
+          super(builder)
+          @right  = right
+          @negate = negate
+        end
+        attr_reader :right, :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)
+          commons  = left.to_attr_list & right.to_attr_list
+          subquery = Clip.new(commons, :star, builder).call(right)
+          if commons.size == 0
+            predicate = builder.exists(subquery)
+          elsif commons.size == 1
+            identifier = left.desaliaser[commons.to_a.first]
+            predicate  = Predicate::Factory.in(identifier, subquery)
+          else
+            join_pre  = join_predicate(left, subquery, commons)
+            subquery  = expand_where_clause(subquery, join_pre)
+            predicate = builder.exists(subquery)
+          end
+          expand_where_clause(left, negate ? !predicate : predicate)
+        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 Alf

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

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

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

@@ -0,0 +1,25 @@
+module Alf
+  module Sql
+    class Processor
+      class Where < Processor
+
+        def initialize(predicate, builder)
+          super(builder)
+          @predicate = predicate
+        end
+
+        def on_select_exp(sexpr)
+          pred = @predicate.rename(sexpr.desaliaser).sexpr
+          if sexpr.where_clause
+            anded = [:and, sexpr.where_clause.predicate, pred ]
+            anded = Alf::Predicate::Grammar.sexpr(anded)
+            sexpr.with_update(:where_clause, [ :where_clause, anded ])
+          else
+            sexpr.with_insert(4, [ :where_clause, pred ])
+          end
+        end
+
+      end # class Where
+    end # class Processor
+  end # module Sql
+end # module Alf

data/lib/alf/sql/version.rb

@@ -0,0 +1,16 @@
+module Alf
+  module Sql
+    module Version
+
+      MAJOR = 0
+      MINOR = 15
+      TINY  = 0
+
+      def self.to_s
+        [ MAJOR, MINOR, TINY ].join('.')
+      end
+
+    end
+    VERSION = Version.to_s
+  end
+end

data/spec/algebra/operand/test_to_sql.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    describe Operand, "to_sql" do
+
+      subject{ op.to_sql }
+
+      context 'when to_cog does not support to_sql' do
+        let(:op) { restrict(suppliers, city: 'London') }
+
+        before do
+          op.to_cog.should_not respond_to(:to_sql)
+        end
+
+        it{ should eq("SELECT t1.sid, t1.name, t1.status, t1.city FROM suppliers AS t1 WHERE t1.city = 'London'") }
+      end
+
+      context 'when to_cog does support to_sql' do
+        let(:op) { restrict(suppliers, city: 'London') }
+
+        before do
+          def op.to_sql
+            :foo
+          end
+        end
+
+        it{ should eq(:foo) }
+      end
+
+    end
+  end
+end

data/spec/builder/test_order_by_clause.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe Builder, "order_by_clause" do
+
+      let(:ordering){ Ordering.new([[:name, :asc], [:city, :desc]]) }
+
+      context 'without desaliaser' do
+        subject{ builder.order_by_clause(ordering) }
+
+        let(:expected){
+          [:order_by_clause,
+            [:order_by_term, [:column_name, 'name'], 'asc'],
+            [:order_by_term, [:column_name, 'city'], 'desc'] ]
+        }
+
+        it{ should eq(expected) }
+      end
+
+      context 'with a desaliaser' do
+        let(:desaliaser){
+          ->(a){
+            if a == "name"
+              [:qualified_name, [:range_var_name, "t1"], [:column_name, a]]
+            else
+              nil
+            end
+          }
+        }
+
+        subject{ builder.order_by_clause(ordering, &desaliaser) }
+
+        let(:expected){
+          [:order_by_clause,
+            [:order_by_term, [:qualified_name, [:range_var_name, "t1"], [:column_name, 'name']], 'asc'],
+            [:order_by_term, [:column_name, 'city'], 'desc'] ]
+        }
+
+        it{ should eq(expected) }
+      end
+
+    end
+  end
+end

data/spec/helpers/ast.rb

@@ -0,0 +1,242 @@
+module Helpers
+  module Ast
+
+    def sexpr(arg)
+      Alf::Sql::Grammar.sexpr(arg)
+    end
+
+    def with_exp(spec, selection = select_ab)
+      sexpr [:with_exp, with_spec(spec), selection]
+    end
+
+    def with_spec(spec = nil)
+      spec = {} if spec.nil?
+      sexpr spec.map{|k,v|
+        [:name_intro, [:table_name, k.to_s], v]
+      }.unshift(:with_spec)
+    end
+
+    def union(left = select_all, right = select_all_t2)
+      sexpr [:union, distinct, left, right]
+    end
+
+    def except(left = select_all, right = select_all_t2)
+      sexpr [:except, distinct, left, right]
+    end
+
+    def intersect(left = select_all, right = select_all_t2)
+      sexpr [:intersect, distinct, left, right]
+    end
+
+    def select_is_table_dee(where)
+      exists = Alf::Predicate::Grammar.sexpr([:exists, where])
+      sexpr [:select_exp, all,
+              [:select_list,
+                [:select_item,
+                  [:literal, true],
+                  [:column_name, "is_table_dee"]] ],
+              [:where_clause, exists] ]
+    end
+
+    def select_ab
+      sexpr [:select_exp, all, select_list, from_clause]
+    end
+
+    def select_a
+      sexpr [:select_exp, all, select_list_a, from_clause]
+    end
+
+    def select_distinct
+      sexpr [:select_exp, distinct, select_list, from_clause]
+    end
+
+    def select_distinct_star
+      sexpr [:select_exp, distinct, select_star, from_clause]
+    end
+
+    def select_distinct_ab
+      sexpr [:select_exp, distinct, select_list_ab, from_clause]
+    end
+
+    def select_distinct_a
+      sexpr [:select_exp, distinct, select_list_a, from_clause]
+    end
+
+    def select_all
+      sexpr [:select_exp, all, select_list, from_clause]
+    end
+
+    def select_all_star
+      sexpr [:select_exp, all, select_star, from_clause]
+    end
+
+    def select_all_from_t1_as_t2
+      sexpr [:select_exp, all, select_list_t2, from_clause_t1_as_t2]
+    end
+
+    def select_all_t2
+      sexpr [:select_exp, all, select_list_t2, from_clause_t2]
+    end
+
+    def select_all_t3
+      sexpr [:select_exp, all, select_list_t3, from_clause_t3]
+    end
+
+    def select_all_ab
+      sexpr [:select_exp, all, select_list_ab, from_clause]
+    end
+
+    def select_all_a
+      sexpr [:select_exp, all, select_list_a, from_clause]
+    end
+
+    def select_all_a_as_b
+      sexpr [:select_exp, all, select_list_a_as_b, from_clause]
+    end
+
+    def select_all_b
+      sexpr [:select_exp, all, select_list_b, from_clause]
+    end
+
+    def select_star
+      sexpr [:select_star]
+    end
+
+    def select_list(hash = {"a" => "a", "b" => "b"})
+      sexpr [:select_list] + hash.map{|(k,v)| select_item(k, v) }
+    end
+    alias :select_list_ab :select_list
+
+    def select_list_t2
+      sexpr [:select_list, select_item_a_t2, select_item_b_t2 ]
+    end
+
+    def select_list_t3
+      sexpr [:select_list, select_item_a_t3, select_item_b_t3 ]
+    end
+
+    def select_list_ab
+      sexpr [:select_list, select_item_a, select_item_b]
+    end
+
+    def select_list_ba
+      sexpr [:select_list, select_item_b, select_item_a]
+    end
+
+    def select_list_a
+      sexpr [:select_list, select_item_a]
+    end
+
+    def select_list_a_as_b
+      sexpr [:select_list, select_item("a","b")]
+    end
+
+    def select_list_b
+      sexpr [:select_list, select_item_b]
+    end
+
+    def select_item_a
+      select_item("a")
+    end
+
+    def select_item_a_t2
+      select_item(qualified_name("t2", "a"), "a")
+    end
+
+    def select_item_a_t3
+      select_item(qualified_name("t3", "a"), "a")
+    end
+
+    def select_item_b_t2
+      select_item(qualified_name("t2", "b"), "b")
+    end
+
+    def select_item_b_t3
+      select_item(qualified_name("t3", "b"), "b")
+    end
+
+    def select_item_b
+      select_item("b")
+    end
+
+    def select_item(name, as = name)
+      name = qualified_name("t1", name) unless name.is_a?(Array)
+      sexpr [:select_item, name, column_name(as)]
+    end
+
+    def column_name_a
+      column_name("a")
+    end
+
+    def column_name_b
+      column_name("b")
+    end
+
+    def column_name(x)
+      sexpr [:column_name, x]
+    end
+
+    def qualified_name_a
+      qualified_name("t1", "a")
+    end
+
+    def qualified_name_b
+      qualified_name("t2", "b")
+    end
+
+    def qualified_name(qualifier, name)
+      sexpr [:qualified_name, [:range_var_name, qualifier], [:column_name, name]]
+    end
+
+    def from_clause
+      sexpr [:from_clause, [:table_as, [:table_name, "t1"], [:range_var_name, "t1"]]]
+    end
+
+    def from_clause_t2
+      sexpr [:from_clause, [:table_as, [:table_name, "t2"], [:range_var_name, "t2"]]]
+    end
+
+    def from_clause_t1_as_t2
+      sexpr [:from_clause, [:table_as, [:table_name, "t1"], [:range_var_name, "t2"]]]
+    end
+
+    def from_clause_t3
+      sexpr [:from_clause, [:table_as, [:table_name, "t3"], [:range_var_name, "t3"]]]
+    end
+
+    def ordering
+      Alf::Ordering.new([[:a, :asc], [:b, :desc]])
+    end
+
+    def subordering
+      Alf::Ordering.new([[:a, :desc], [:b, :asc]])
+    end
+
+    def order_by_clause
+      [:order_by_clause,
+        order_by_term("a", "asc"),
+        order_by_term("b", "desc")]
+    end
+
+    def order_by_clause_2
+      [:order_by_clause,
+        order_by_term("a", "desc"),
+        order_by_term("b", "asc")]
+    end
+
+    def order_by_term(name, direction)
+      name = qualified_name("t1", name) unless name.is_a?(Array)
+      sexpr [:order_by_term, name, direction]
+    end
+
+    def distinct
+      [:set_quantifier, "distinct"]
+    end
+
+    def all
+      [:set_quantifier, "all"]
+    end
+
+  end
+  include Ast
+end