alf-sql 0.15.0

data/spec/helpers/compiler.rb

@@ -0,0 +1,23 @@
+module Helpers
+  module Compiler
+
+    def an_operand(cog = nil)
+      Alf::Algebra::Operand::Fake.new(nil, cog)
+    end
+
+    def compiler
+      @compiler ||= Alf::Sql::Compiler.new
+    end
+
+    def builder(start = 0)
+      @builder ||= Alf::Sql::Builder.new(start)
+    end
+
+    def suppliers
+      @suppliers ||= an_operand.with_name(:suppliers)
+                               .with_heading(sid: String, name: String, status: Integer, city: String)
+    end
+
+  end
+  include Compiler
+end

data/spec/nodes/column_name/test_as_name.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe ColumnName, "as_name" do
+
+      subject{ expr.as_name }
+
+      let(:expr){ column_name_a }
+
+      it{ should eq("a") }
+
+    end
+  end
+end

data/spec/nodes/column_name/test_qualifier.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe ColumnName, "qualifier" do
+
+      subject{ expr.qualifier }
+
+      let(:expr){ column_name_a }
+
+      it{ should be_nil }
+
+    end
+  end
+end

data/spec/nodes/order_by_clause/test_to_ordering.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe OrderByClause, "to_ordering" do
+
+      subject{ expr.to_ordering }
+
+      let(:ordering){
+        Ordering.new([[:a, :asc], [:b, :desc]])
+      }
+
+      context 'when not qualified' do
+        let(:expr){ builder.order_by_clause(ordering) }
+
+        it{ should eq(ordering) }
+      end
+
+      context 'when qualified' do
+        let(:expr){
+          builder.order_by_clause(ordering){|a|
+            [:qualified_name, [:range_var_name, "t1"], [:column_name, a]]
+          }
+        }
+
+        it{ should eq(ordering) }
+      end
+
+    end
+  end
+end

data/spec/nodes/order_by_term/test_as_name.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe OrderByTerm, "as_name" do
+
+      subject{ expr.as_name }
+
+      context 'when qualified' do
+        let(:expr){ order_by_term(qualified_name('t1', 'a'), "asc") }
+
+        it{ should eq('a') }
+      end
+
+      context 'when not qualified' do
+        let(:expr){ order_by_term(column_name_a, "asc") }
+
+        it{ should eq('a') }
+      end
+
+    end
+  end
+end

data/spec/nodes/order_by_term/test_direction.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe OrderByTerm, "direction" do
+
+      subject{ expr.direction }
+
+      context 'when qualified' do
+        let(:expr){ order_by_term(qualified_name('t1', 'a'), "asc") }
+
+        it{ should eq('asc') }
+      end
+
+      context 'when not qualified' do
+        let(:expr){ order_by_term(column_name_a, "asc") }
+
+        it{ should eq('asc') }
+      end
+
+    end
+  end
+end

data/spec/nodes/order_by_term/test_qualifier.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe OrderByTerm, "qualifier" do
+
+      subject{ expr.qualifier }
+
+      context 'when qualified' do
+        let(:expr){ order_by_term(qualified_name('t1', 'a'), "asc") }
+
+        it{ should eq('t1') }
+      end
+
+      context 'when not qualified' do
+        let(:expr){ order_by_term(column_name_a, "asc") }
+
+        it{ should be_nil }
+      end
+
+    end
+  end
+end

data/spec/nodes/select_exp/test_order_by_clause.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe SelectExp, "order_by_clause" do
+
+      subject{ expr.order_by_clause }
+
+      context 'when an order by clause' do
+        let(:expr){ select_all.push(order_by_clause) }
+
+        it{ should eq(order_by_clause) }
+      end
+
+      context 'without such clause' do
+        let(:expr){ select_all }
+
+        it{ should be_nil }
+      end
+
+    end
+  end
+end

data/spec/nodes/select_item/test_as_name.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    describe SelectItem, "as_name" do
+
+      subject{ expr.as_name }
+
+      context 'on a select item with no real renaming' do
+        let(:expr){ select_item("a", "a") }
+
+        it{ should eq("a") }
+      end
+
+      context 'on a select item with with real renaming' do
+        let(:expr){ select_item("a", "x") }
+
+        it{ should eq("x") }
+      end
+
+    end
+  end
+end

data/spec/predicate/nodes/exists/test_not.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Exists, "!" do
+
+      let(:expr){
+        Grammar.sexpr [:exists, :foo]
+      }
+
+      let(:expected){
+        Grammar.sexpr [:not, [:exists, :foo]]
+      }
+
+      subject{ !expr }
+
+      it{ should eq(expected) }
+
+    end
+  end
+end

data/spec/processor/clip/test_on_select_exp.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    class Processor
+      describe Clip, "on_select_exp" do
+
+        subject{ Clip.new(AttrList[:a], Builder.new).on_select_exp(expr) }
+
+        context 'normal_case' do
+          let(:expr){ select_all }
+
+          it{ should eq(select_all_a) }
+        end
+
+        context 'distinct_case' do
+          let(:expr){ select_distinct }
+
+          it{ should eq(select_distinct_a) }
+        end
+
+        context 'when leading to an empty select_list' do
+          let(:expr){ select_all_b }
+
+          context 'the default behavior' do
+            it{ should eq(select_is_table_dee(select_all_star)) }
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/processor/clip/test_on_select_list.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    class Processor
+      describe Clip, "on_select_list" do
+
+        subject{ Clip.new(AttrList[:a], Builder.new).on_select_list(expr) }
+
+        context 'when included' do
+          let(:expr){ select_list_ab }
+
+          it{ should eq(select_list_a) }
+        end
+
+        context 'when unique' do
+          let(:expr){ select_list_a }
+
+          it{ should eq(select_list_a) }
+        end
+
+      end
+    end
+  end
+end

data/spec/processor/distinct/test_on_set_quantified.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    class Processor
+      describe Distinct, "on_set_quantified" do
+
+        subject{ Distinct.new(Builder.new).on_set_quantified(expr) }
+
+        let(:expected){
+          [:x, distinct]
+        }
+
+        context 'when already distinct' do
+          let(:expr){
+            Grammar.sexpr [:x, distinct]
+          }
+
+          it{ should eq(expected) }
+        end
+
+        context 'when not distinct' do
+          let(:expr){
+            Grammar.sexpr [:x, all]
+          }
+
+          it{ should eq(expected) }
+        end
+      end
+    end
+  end
+end

data/spec/processor/from_self/test_on_nonjoin_exp.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    class Processor
+      describe FromSelf, "on_nonjoin_exp" do
+
+        subject{ FromSelf.new(builder).on_nonjoin_exp(expr) }
+
+        context 'on select_exp' do
+          let(:expr){
+            select_all
+          }
+
+          let(:expected){
+            with_exp(t1: select_all)
+          }
+
+          it{ should eq(expected) }
+        end
+
+        context 'on union' do
+          let(:expr){
+            union
+          }
+
+          let(:expected){
+            with_exp(t1: union)
+          }
+
+          it{ should eq(expected) }
+        end
+
+        context 'on intersect' do
+          let(:expr){
+            intersect
+          }
+
+          let(:expected){
+            with_exp(t1: intersect)
+          }
+
+          it{ should eq(expected) }
+        end
+
+        context 'on except' do
+          let(:expr){
+            except
+          }
+
+          let(:expected){
+            with_exp(t1: except)
+          }
+
+          it{ should eq(expected) }
+        end
+
+      end
+    end
+  end
+end

data/spec/processor/from_self/test_on_with_exp.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    class Processor
+      describe FromSelf, "on_with_exp" do
+
+        subject{ FromSelf.new(builder(1)).on_with_exp(expr) }
+
+        let(:expr){
+          with_exp({t1: select_all}, select_all_t2)
+        }
+
+        let(:expected){
+          with_exp({t1: select_all, t2: select_all_t2}, select_all_t2)
+        }
+
+        it{ should eq(expected) }
+
+      end
+    end
+  end
+end

data/spec/processor/merge/test_on_select_exp.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+module Alf
+  module Sql
+    class Processor
+      describe Merge, "on_select_exp" do
+
+        subject{ Merge.new(:intersect, right, builder(1)).on_select_exp(expr) }
+
+        context 'when right a simple select_exp' do
+          let(:expr){
+            # SELECT * FROM t1
+            select_all
+          }
+
+          let(:right){
+            # SELECT * FROM t2
+            select_all_t2
+          }
+
+          let(:expected){
+            # SELECT * FROM t1 INTERSECT SELECT * FROM t2
+            intersect
+          }
+
+          it{ should eq(expected) }
+        end
+
+        context 'when right an intersect' do
+          let(:expr){
+            # SELECT * FROM t1
+            select_all
+          }
+
+          let(:right){
+            # SELECT * FROM t1 INTERSECT SELECT * FROM t2
+            intersect
+          }
+
+          let(:expected){
+            # SELECT * FROM t1 INTERSECT SELECT * FROM t1 INTERSECT SELECT * FROM t2
+            intersect(expr, right)
+          }
+
+          it{ should eq(expected) }
+        end
+
+        context 'when right is a with_exp' do
+          let(:expr){
+            # SELECT * FROM t1
+            select_all
+          }
+
+          let(:right){
+            # WITH t2 AS ...
+            # SELECT * FROM t2
+            with_exp({t2: select_all_t2}, select_all_t2)
+          }
+
+          let(:expected){
+            # WITH t2 AS ...
+            # SELECT * FROM t1 INTERSECT SELECT * FROM t2
+            with_exp(
+              {t2: select_all_t2},
+              intersect(select_all, select_all_t2))
+          }
+
+          it{ should eq(expected) }
+        end
+
+      end
+    end
+  end
+end